36 static int32_t max(int32_t a, int32_t b)
 
   48     memset(matrix, 0, 
sizeof(matrix[0][0]) * m * n);
 
   53     memset(matrix, value, 
sizeof(matrix[0][0]) * m * n);
 
   61     for (i = 0; i < m; i++) {
 
   62         for (j = 0; j < n; j++) {
 
   63             dest_matrix[j][i] = src_matrix[i][j];
 
   74     for (i = 0; i < m; i++) {
 
   75         for (j = i + 1; j < m; j++) {
 
   77             matrix[i][j] = matrix[j][i];
 
   86     memcpy(dest_matrix, src_matrix, 
sizeof(
matrix_t) * m * n);
 
   90                       uint8_t start_row_ind, uint8_t end_row_ind,
 
   91                       uint8_t start_col_ind, uint8_t end_col_ind,
 
   92                       uint8_t dest_row_num, uint8_t dest_col_num,
 
   93                       matrix_t dest_matrix[][dest_col_num])
 
   97     if ((end_row_ind > start_row_ind) && (end_col_ind > start_col_ind)) {
 
   98         for (i = start_row_ind;
 
  100              && ((i - start_row_ind)
 
  103             for (j = start_col_ind;
 
  105                  && ((j - start_col_ind)
 
  108                 dest_matrix[i - start_row_ind][j - start_col_ind] =
 
  115         if ((start_row_ind == end_row_ind)
 
  116             && (start_col_ind == end_col_ind)) {
 
  118             dest_matrix[start_row_ind][start_row_ind] =
 
  119                 src_matrix[start_row_ind][start_row_ind];
 
  122         else if (start_row_ind == end_row_ind) {
 
  124             for (j = start_col_ind; j <= end_col_ind; j++) {
 
  125                 dest_matrix[start_row_ind][i++] =
 
  126                     src_matrix[start_row_ind][j];
 
  130         else if (start_col_ind == end_col_ind) {
 
  132             for (i = start_row_ind; i <= end_row_ind; i++) {
 
  133                 dest_matrix[j++][start_col_ind] =
 
  134                     src_matrix[i][start_col_ind];
 
  146     for (i = 0; i < m; i++) {
 
  148         for (j = 0; j < n; j++) {
 
  149             printf(
"%7.4f", matrix[i][j]);
 
  165                        uint8_t start_row_ind, uint8_t end_row_ind,
 
  166                        uint8_t start_col_ind, uint8_t end_col_ind)
 
  170     if ((end_row_ind > start_row_ind) && (end_col_ind > start_col_ind)) {
 
  172         for (i = start_row_ind; i <= end_row_ind; i++) {
 
  174             for (j = start_col_ind; j <= end_col_ind; j++) {
 
  175                 printf(
"%7.4f", matrix[i][j]);
 
  176                 if (j < end_col_ind) {
 
  181             if (i < end_row_ind) {
 
  190         if ((start_row_ind == end_row_ind)
 
  191             & (start_col_ind == end_col_ind)) {
 
  193             printf(
"{%3.4f}", matrix[start_row_ind][start_col_ind]);
 
  196         else if (start_row_ind == end_row_ind) {
 
  198             for (j = start_col_ind; j <= end_col_ind; j++) {
 
  199                 printf(
"%3.4f", matrix[start_row_ind][j]);
 
  200                 if (j < end_col_ind) {
 
  207         else if (start_col_ind == end_col_ind) {
 
  209             for (i = start_row_ind; i <= end_row_ind; i++) {
 
  210                 printf(
"%3.4f", matrix[i][start_col_ind]);
 
  211                 if (i < end_row_ind) {
 
  221                        uint8_t before_dot, uint8_t after_dot)
 
  224     char format_str_buff[13];
 
  226     sprintf(format_str_buff, 
"%%%u.%uf", before_dot, after_dot);
 
  229     for (i = 0; i < m; i++) {
 
  231         for (j = 0; j < n; j++) {
 
  243     printf(
"%7s\n", 
"};");
 
  248                             uint8_t start_row_ind, uint8_t end_row_ind,
 
  249                             uint8_t start_col_ind, uint8_t end_col_ind,
 
  250                             uint8_t before_dot, uint8_t after_dot)
 
  253     char format_str_buff[13];
 
  255     sprintf(format_str_buff, 
"%%%u.%uf", before_dot, after_dot);
 
  257     if ((end_row_ind > start_row_ind) && (end_col_ind > start_col_ind)) {
 
  259         for (i = start_row_ind; i <= end_row_ind; i++) {
 
  261             for (j = start_col_ind; j <= end_col_ind; j++) {
 
  263                 if (j < end_col_ind) {
 
  268             if (i < end_row_ind) {
 
  273         printf(
"%11s\n", 
"};");
 
  277         if ((start_row_ind == end_row_ind)
 
  278             & (start_col_ind == end_col_ind)) {
 
  281                          matrix[start_row_ind][start_col_ind]);
 
  285         else if (start_row_ind == end_row_ind) {
 
  287             for (j = start_col_ind; j <= end_col_ind; j++) {
 
  289                              matrix[start_row_ind][j]);
 
  290                 if (j < end_col_ind) {
 
  297         else if (start_col_ind == end_col_ind) {
 
  299             for (i = start_row_ind; i <= end_row_ind; i++) {
 
  301                              matrix[i][start_col_ind]);
 
  302                 if (i < end_row_ind) {
 
  317     double eps = pow(2.0, -52.0);
 
  318     double tol = max(m, n) * singl_values_arr[0] * eps;
 
  320     for (i = 0; i < length; i++) {
 
  321         if (singl_values_arr[i] > tol) {
 
  334     for (i = 0; i < m; i++) {
 
  335         for (j = 0; j < n; j++) {
 
  336             A_minus_B[i][j] = A[i][j] - B[i][j];
 
  346     for (i = 0; i < m; i++) {
 
  347         for (j = 0; j < n; j++) {
 
  348             A_plus_B[i][j] = A[i][j] + B[i][j];
 
  358     for (i = 0; i < diag_el_num; i++) {
 
  364                 matrix_t a_matrix[a_line_num][a_col_num],
 
  365                 uint8_t b_line_num, uint8_t b_col_num,
 
  366                 matrix_t b_matrix[b_line_num][b_col_num],
 
  367                 matrix_t dest_matrix[a_line_num][b_col_num])
 
  372     if (a_col_num != b_line_num) {
 
  374             "the first matrix column number must be equal with the line number" 
  375             " of the second matrix !!!");
 
  379         for (i = 0; i < a_line_num; i++) {
 
  380             for (j = 0; j < b_col_num; j++) {
 
  381                 dest_matrix[i][j] = 0;
 
  382                 for (k = 0; k < b_line_num; k++) {
 
  383                     dest_matrix[i][j] += a_matrix[i][k]
 
  392                      uint8_t b_col_num_max, 
matrix_t b_matrix[][b_col_num_max],
 
  393                      uint8_t a_start_row_ind, uint8_t a_end_row_ind,
 
  394                      uint8_t a_start_col_ind, uint8_t a_end_col_ind,
 
  395                      uint8_t b_start_row_ind, uint8_t b_end_row_ind,
 
  396                      uint8_t b_start_col_ind, uint8_t b_end_col_ind,
 
  397                      uint8_t dest_col_size,
 
  398                      matrix_t dest_matrix[][dest_col_size])
 
  404     if ((a_end_col_ind - a_start_col_ind)
 
  405         != (b_end_row_ind - b_start_row_ind)) {
 
  407             "the first matrix column number must be equal with the line number" 
  408             " of the second matrix !!!");
 
  412         a_line_num = a_end_row_ind - a_start_row_ind + 1;
 
  413         b_line_num = b_end_row_ind - b_start_row_ind + 1;
 
  414         b_col_num = b_end_col_ind - b_start_col_ind + 1;
 
  416         for (uint8_t i = 0; i < a_line_num; i++) {
 
  417             for (uint8_t j = 0; j < b_col_num; j++) {
 
  418                 dest_matrix[i][j] = 0;
 
  419                 for (uint8_t k = 0; k < b_line_num; k++) {
 
  440     if (vec != dst_arr) {
 
  441         memset(dst_arr, 0, m * 
sizeof(
matrix_t));
 
  444     for (i = 0; i < m; i++) {
 
  445         for (j = 0; j < n; j++) {
 
  446             dst_arr[i] += matrix[i][j] * vec[j];
 
  458     if (vec != dst_arr) {
 
  459         memset(dst_arr, 0, n * 
sizeof(
matrix_t));
 
  462     for (i = 0; i < n; i++) {       
 
  463         for (j = 0; j < m; j++) {   
 
  464             dst_arr[i] += vec[j] * matrix[j][i];
 
  477     if (vec != dst_arr) {
 
  478         memset(dst_arr, 0, n * 
sizeof(
matrix_t));
 
  481     for (i = 0; i < n; i++) {       
 
  482         for (j = 0; j < m; j++) {   
 
  483             dst_arr[i] += scalar * vec[j] * matrix[j][i];
 
  492                                      uint8_t begin_row, uint8_t begin_column,
 
  493                                      matrix_t dst_arr[max_n - begin_row])
 
  497     if (vec != dst_arr) {
 
  498         memset(dst_arr, 0, (max_n - begin_row) * 
sizeof(
matrix_t));
 
  501     for (i = begin_column; i < max_n; i++) {    
 
  502         for (j = begin_row; j < max_m; j++) {   
 
  503             dst_arr[i - begin_column] += scalar * vec[j - begin_row]
 
  518             "The vector size should be equal the raw number of the matrix !!!");
 
  521         for (j = 0; j < n; j++) {
 
  523             for (i = 0; i < m; i++) {
 
  524                 c_vec[j] += A[i][j] * b_vec[i];
 
  537     for (i = 0; i < m; i++) {
 
  538         for (j = 0; j < n; j++) {
 
  539             res_mat[i][j] = col_vec[i] * row_vec[j];
 
  552     for (i = 0; i < n; i++) {
 
  554         for (j = 0; j < n; j++) {
 
  557             for (k = 0; k < m; k++) {
 
  558                 AT_mul_A[i][j] += column_vec[k]
 
  576     for (uint8_t i = 0; i < max; i++) {
 
  577         diag_matrix[i][i] = value;
 
  588     for (i = 0; i < length; i++) {
 
  589         diag_matrix[i][i] = vec[i];
 
  605     for (
int i = 0; i < m; i++) {
 
  606         for (
int j = 0; j < n; j++) {
 
  607             mat_dest[i][j] = value * mat_src[i][j];
 
  613                            uint8_t col_num, 
matrix_t col_vec[m])
 
  617     for (i = 0; i < m; i++) {
 
  618         col_vec[i] = matrix[i][col_num];
 
  624                                 matrix_t matrix[max_m][max_n], uint8_t col_num,
 
  630     for (i = offset; i < max_m; i++) {
 
  631         col_vec[i - offset] = matrix[i][col_num];
 
  636                                        matrix_t matrix[m][n], uint8_t col_num)
 
  641     elem_max = matrix[0][col_num];
 
  642     for (i = 1; i < m; i++) {
 
  643         if (matrix[i][col_num] > elem_max) {
 
  644             elem_max = matrix[i][col_num];
 
  658     abs_max_elem = fabs(matrix[0][col_num]);
 
  659     for (i = 1; i < m; i++) {
 
  660         if (fabs(matrix[i][col_num]) > abs_max_elem) {
 
  661             abs_max_elem = fabs(matrix[i][col_num]);
 
  670                                             uint8_t row_num, uint8_t col_num)
 
  675     max_elem = matrix[row_num][col_num];
 
  676     for (i = row_num + 1; i < max_m; i++) {
 
  677         if (matrix[i][col_num] > max_elem) {
 
  678             max_elem = matrix[i][col_num];
 
  693     abs_max_elem = fabs(matrix[row_num][col_num]);
 
  694     for (i = row_num + 1; i < max_m; i++) {
 
  695         if (fabs(matrix[i][col_num]) > abs_max_elem) {
 
  696             abs_max_elem = fabs(matrix[i][col_num]);
 
  706                                                           uint8_t row_num, uint8_t col_num,
 
  712     abs_max_elem = fabs(matrix[row_num][col_num]);
 
  714     for (i = row_num + 1; i < max_m; i++) {
 
  715         if (fabs(matrix[i][col_num]) > abs_max_elem) {
 
  716             abs_max_elem = fabs(matrix[i][col_num]);
 
  729     for (uint8_t k = 0; k < n; k++) {
 
  731         matrix[i][k] = matrix[j][k];
 
  737                            uint8_t j, uint8_t col_begin,
 
  742     if (col_begin <= col_end) {
 
  743         for (uint8_t k = col_begin; k < (col_end + 1); k++) {
 
  745             matrix[i][k] = matrix[j][k];
 
  754     double two_norm = 0.0;
 
  784     double frob_norm = 0.0;
 
  786     for (uint8_t i = 0; i < m; i++) {
 
  787         for (uint8_t j = 0; j < n; j++) {
 
  788             frob_norm += pow(A[i][j], 2);
 
  792     return sqrt(frob_norm);
 
  800     for (uint8_t i = 0; i < n; i++) {
 
  802             inv_U[i][i] = 1 / U[i][i];
 
  805             inv_U[i][i] = FLT_MAX;
 
  807         for (uint8_t j = 0; j <= (i - 1); j++) {
 
  809             for (uint8_t k = j; k <= (i - 1); k++) {
 
  810                 u = u + U[k][i] * inv_U[j][k];
 
  812             inv_U[j][i] = -u * inv_U[i][i];
 
  822     for (uint8_t i = 0; i < n; i++) {
 
  823         if ((i <= m) & (i <= n)) {
 
  825                 inv_L[i][i] = 1 / L[i][i];
 
  828                 inv_L[i][i] = FLT_MAX;
 
  830             for (uint8_t j = 0; j <= (i - 1); j++) {
 
  832                 for (uint8_t k = j; k <= (i - 1); k++) {
 
  833                     l = l + L[i][k] * inv_L[k][j];
 
  835                 inv_L[i][j] = -l * inv_L[i][i];
 
  845     if ((&A[0][0]) == (&tr_up_A[0][0])) {
 
  846         for (uint8_t i = 1; i < m; i++) {
 
  847             for (uint8_t j = 0; (j < i) && (j < n); j++) {
 
  854         for (uint8_t i = 0; i < m; i++) {
 
  855             for (uint8_t j = 0; j < n; j++) {
 
  857                     tr_up_A[i][j] = A[i][j];
 
  872     if ((&A[0][0]) == (&tr_low_A[0][0])) {
 
  874         for (uint8_t i = 0; i < m; i++) {
 
  875             for (uint8_t j = i + 1; (j > i) && (j < n); j++) {
 
  882         for (uint8_t i = 0; i < m; i++) {
 
  883             for (uint8_t j = 0; j < n; j++) {
 
  885                     tr_low_A[i][j] = A[i][j];