| RcdMathLib_doc
    Open Source Library  for Linear and Non-linear Algebra | 
 
 
 
Go to the documentation of this file.
   86     get_jacobian(x_vec, J);
 
   98     get_f_error(x_vec, data_vec, f_vec);
 
  105     get_f_error(x_vec, data_vec, Fx);
 
  114     get_f_error(x_plus_s, data_vec, F_x_plus_s);
 
  124     vector_add(f_length, Fx, Fx_plus_J_mul_s, Fx_plus_J_mul_s);
 
  131     denom = Fx_square - Fx_plus_J_mul_s_square;
 
  133         ro_mu = (Fx_square - Fx_plus_s_square) / denom;
 
  136         puts(
"ro_mu is infinite !!!");
 
  148                                 uint8_t max_iter_num,
 
  150                                 void (*get_f_error)(
vector_t x0_vec[],
 
  153                                 void (*get_jacobian)(
vector_t x0_vec[],
 
  170     get_jacobian(x0_vec, J);
 
  185     get_f_error(x0_vec, data_vec, f_vec);
 
  196            && (it < max_iter_num)) {   
 
  204             if (ro_mu <= beta0) {
 
  209                     data_vec, mu, s, get_f_error,
 
  212             else if (ro_mu >= beta1) {
 
  232     for (uint8_t i = 1; i < n; i++) {
 
  233         if (JTJ[i][i] > max_diag_JTJ) {
 
  234             max_diag_JTJ = JTJ[i][i];
 
  238     return tau * max_diag_JTJ;
 
  
 
vector_t vector_get_norm2(uint8_t length, vector_t arr[])
Compute the 2-norm norm of a vector.
void matrix_mul_vec(uint8_t m, uint8_t n, matrix_t matrix[m][n], matrix_t vec[n], matrix_t dst_arr[m])
Compute the multiplication of a matrix with a column vector.
uint8_t opt_levenberg_marquardt(uint8_t f_length, uint8_t n, vector_t x0_vec[n], vector_t data_vec[f_length], matrix_t eps, matrix_t tau, matrix_t beta0, matrix_t beta1, uint8_t max_iter_num, vector_t est_x_vec[n], void(*get_f_error)(vector_t x0_vec[], vector_t data_vec[], vector_t f_vec[]), void(*get_jacobian)(vector_t x0_vec[], matrix_t J[][n]))
Implements the Levenberg–Marquardt (LVM) algorithm.
vector_t vector_get_scalar_product(uint8_t n, vector_t vec1[n], vector_t vec2[n])
Compute the dot product of two vectors.
int8_t solve_householder(uint8_t m, uint8_t n, matrix_t A[][n], matrix_t b[m], matrix_t x_sol[n])
Solve an (m  n) linear system Ax = b, using the Householder algorithm.
#define vector_t
Define the data type of the vector elements.
void matrix_trans_mul_itself(uint8_t m, uint8_t n, matrix_t A[m][n], matrix_t AT_mul_A[n][n])
Compute the multiplication of the transpose of a matrix with itself.
void matrix_add_to_diag(uint8_t n, matrix_t A[][n], uint8_t diag_el_num, matrix_t value)
Add a number to diagonal elements of a matrix.
void matrix_trans_mul_vec(uint8_t m, uint8_t n, matrix_t A[m][n], uint8_t b_size, matrix_t b_vec[m], matrix_t c_vec[n])
Compute the multiplication of transposed matrix with column vector.
Enables to solve systems of linear equations Ax = b for x.
Utilities for linear algebra.
matrix_t opt_levenberg_marquardt_correction(uint8_t f_length, uint8_t n, matrix_t x_vec[n], matrix_t data_vec[f_length], matrix_t mu, matrix_t s[n], void(*get_f_error)(vector_t x_vec[], vector_t data_vec[], vector_t f_vec[]), void(*get_jacobian)(vector_t x_vec[], matrix_t J[][n]))
Implements the correction-function of the Levenberg–Marquardt (LVM) algorithm.
void matrix_mul_scalar(uint8_t m, uint8_t n, matrix_t mat_src[m][n], matrix_t value, matrix_t mat_dest[m][n])
Multiply all elements of a matrix with a specified value.
Implement the Levenberg–Marquardt (LVM) algorithm.
void vector_copy(uint8_t size, vector_t src_arr[], vector_t dest_arr[])
Copy the elements of the source vector to the destination vector.
matrix_t opt_levenberg_marquardt_get_mu0(uint8_t n, matrix_t tau, matrix_t JTJ[][n])
Compute the initial value  of the Levenberg–Marquardt (LVM) algorithm.
#define matrix_t
Define the data type of the matrix elements.
void vector_add(uint8_t size, vector_t a_vec[size], vector_t b_vec[size], vector_t a_plus_b_vec[size])
Compute the addition of two vectors.