45     matrix_t ref_value_matrix[4][3] = { { 0, 0, 1.67 },
 
   50     for (i = 0; i < row_num; i++) {
 
   51         denom = sqrt(pow(x0_vec[0] - ref_value_matrix[i][0], 2) +
 
   52                      pow(x0_vec[1] - ref_value_matrix[i][1], 2) +
 
   53                      pow(x0_vec[2] - ref_value_matrix[i][2], 2));
 
   55             J[i][0] = (x0_vec[0] - ref_value_matrix[i][0]) / denom;
 
   56             J[i][1] = (x0_vec[1] - ref_value_matrix[i][1]) / denom;
 
   57             J[i][2] = (x0_vec[2] - ref_value_matrix[i][2]) / denom;
 
   75     matrix_t ref_point_mat[4][3] = { { 0, 0, 1.67 },
 
   80     for (i = 0; i < row_num; i++) {
 
   83                 (x0_vec[0] - ref_point_mat[i][0])
 
   85                    - ref_point_mat[i][0])
 
   88                  - ref_point_mat[i][1])
 
   90                    - ref_point_mat[i][1])
 
   93                  - ref_point_mat[i][2])
 
   95                    - ref_point_mat[i][2])
 
   97             - measured_data_vec[i];
 
  104         "***************** Optimization test *****************");
 
  106     matrix_t true_values_matrix[9][3] = {
 
  119         { 0.9645166, 0.9894337, -0.1127879 },    
 
  120         { 0.9706874, 1.9937843, -0.0767517 },    
 
  121         { 0.9759567, 2.9980380, -0.0421651 },    
 
  122         { 1.9666907, 0.9892634, -0.1184331 },    
 
  123         { 1.9734193, 1.9945307, -0.0776960 },    
 
  124         { 1.9791861, 2.9997600, -0.0385668 },    
 
  125         { 2.9676093, 0.9886335, -0.1290797 },    
 
  126         { 2.9749588, 1.9950495, -0.0824135 },    
 
  127         { 2.9814874, 3.0015139, -0.0370967 },    
 
  130     matrix_t measured_values_matrix[9][4] = {
 
  131         { 2.189355547, 3.732117187, 4.992518309, 4.126940038 },     
 
  132         { 2.791860082, 4.115904867, 4.358726079, 3.195059925 },     
 
  133         { 3.577157155, 4.685985423, 3.883094303, 2.320377599 },     
 
  134         { 2.791860082, 2.810684972, 4.347183679, 4.474971454 },     
 
  135         { 3.285646100, 3.303836609, 3.600904464, 3.633252051 },     
 
  136         { 3.974524884, 3.992093430, 3.006899725, 2.893757310 },     
 
  137         { 3.577157155, 1.968162419, 3.857113556, 5.001588788 },     
 
  138         { 3.974524884, 2.625676627, 2.990106568, 4.264874121 },     
 
  139         { 4.560484620, 3.452531771, 2.238079928, 3.655150652 },     
 
  142     uint8_t vector_values_num = 9;
 
  143     uint8_t f_length = 4;
 
  152     uint8_t max_iter_num = 100;
 
  156     printf(
"\nseeked_values_matrix = ");
 
  160     puts(
"############## PARAMETERS #################");
 
  161     printf(
"eps = %.0e\ntau = %.0e\nfmin = %.0e\n", eps, tau, fmin);
 
  163     for (i = 0; i < vector_values_num; i++) {
 
  167             "\n----------------------------------------- T%u ----------------------------------\n",
 
  169         printf(
"true vector value = {%.4f, %.4f, %.4f}\n",
 
  170                true_values_matrix[i][0],
 
  171                true_values_matrix[i][1],
 
  172                true_values_matrix[i][2]);
 
  173         printf(
"start vector value = ");
 
  178                                          measured_values_matrix[i], eps, fmin,
 
  179                                          max_iter_num, est_values_vec,
 
  181         printf(
"Gauss-Newton solution = ");
 
  184         printf(
"iteration number = %u\n", iter_num);
 
  188                                            measured_values_matrix[i], eps, tau,
 
  189                                            beta0, beta1, max_iter_num,
 
  192         printf(
"Levenberg-Marquardt solution = ");
 
  195         printf(
"iteration number = %u", iter_num);
 
  223     for (i = 1; i < 9; i++) {
 
  224         f_vec[i - 1] = x1 * exp(i * x2) - data_vec[i - 1];
 
  258     for (i = 1; i < 9; i++) {
 
  259         J[i - 1][0] = exp(i * x2);
 
  260         J[i - 1][1] = i * x1 * exp(i * x2);
 
  266     vector_t d_vec[] = { 8.3, 11.0, 14.7, 19.7, 26.7, 35.2, 44.4, 55.9 };
 
  277     uint8_t max_it_num = 3;
 
  278     uint8_t iter_num = 0;
 
  285         "\n\n############### Test Gauss-Newton & LVM algorithms ###############");
 
  286     puts(
"\nExponential Data:");
 
  288                                      max_it_num, est_x_vec,
 
  291     printf(
"start value = {%.6f, %.6f}\n", start_x_vec[0], start_x_vec[1]);
 
  292     printf(
"Gauss-Newton solution = {%.6f, %.6f}\n", est_x_vec[0], est_x_vec[1]);
 
  293     printf(
"iteration number = %d\n", iter_num);
 
  299                                        beta0, beta1, max_it_num,
 
  302     printf(
"Levenberg-Marquardt solution = {%.6f, %.6f}\n", est_x_vec[0],
 
  304     printf(
"iteration number = %d\n", iter_num);
 
  335     for (i = 1; i < 13; i++) {
 
  336         f_vec[i - 1] = x1 * sin(x2 * i + x3) + x4 - data_vec[i - 1];
 
  368     for (i = 1; i < 13; i++) {
 
  369         J[i - 1][0] = sin(i * x2 + x3);
 
  370         J[i - 1][1] = i * x1 * cos(i * x2 + x3);
 
  371         J[i - 1][2] = x1 * cos(i * x2 + x3);
 
  378     vector_t d_vec[] = { 61, 65, 72, 78, 85, 90, 92, 92, 88, 81, 72, 63 };
 
  379     vector_t start_x_vec[] = { 17, 0.5, 10.5, 77 };
 
  389     uint8_t max_it_num = 2;
 
  390     uint8_t iter_num = 0;
 
  397     puts(
"\nSinusoidal Data:");
 
  399                                      max_it_num, est_x_vec,
 
  402     printf(
"start value = {%.6f, %.6f, %.6f, %.6f}\n", start_x_vec[0],
 
  404            start_x_vec[2], start_x_vec[3]);
 
  405     printf(
"Gauss-Newton solution = {%.6f, %.6f, %.6f, %.6f}\n", est_x_vec[0],
 
  407            est_x_vec[2], est_x_vec[3]);
 
  408     printf(
"iteration number = %d\n", iter_num);
 
  414                                        beta0, beta1, max_it_num,
 
  417     printf(
"Levenberg-Marquardt solution = {%.6f, %.6f, %.6f, %.6f}\n", est_x_vec[0],
 
  419            est_x_vec[2], est_x_vec[3]);
 
  420     printf(
"iteration number = %d\n", iter_num);