mbs_matrix.h

Go to the documentation of this file.

 
#ifndef mbs_matrix_h
#define mbs_matrix_h
#include <stdio.h>
#ifdef __cplusplus
extern "C" {
#endif
 
// Macro functions allowing to retrieve static arrays.
#define make_transpose_arr_4x4(mat) {{3, 0, 0, 0}, \
                                     {3, mat[1][1], mat[1][2], mat[1][3]}, \
                                     {3, mat[2][1], mat[2][2], mat[2][3]}, \
                                     {3, mat[3][1], mat[3][2], mat[3][3]}}
 
#define make_transpose_arr_3x3(mat) {{mat[0][0], mat[0][1], mat[0][2]}, \
                                     {mat[1][0], mat[1][1], mat[1][2]}, \
                                     {mat[2][0], mat[2][1], mat[2][2]}}
 
 
#define make_transpose_arr_4x4_to_3x3(mat)\
    {{mat[1][1], mat[1][2], mat[1][3]}, \
     {mat[2][1], mat[2][2], mat[2][3]}, \
     {mat[3][1], mat[3][2], mat[3][3]}}
/*--------------------*/
void transpose(double M[4][4], double Mt[4][4]);
 
void dot_3x3_arr(double res[3], double mat[3][3], double vec[3]);
 
double *dot_3x3_ptr(double *res, double **mat, double *vec);
 
void dot_4x4_arr(double res[4], double mat[4][4], double vec[4]);
 
double *dot_4x4_ptr(double *res, double **mat, double *vec);
 
double *dot_nxm_ptr_0(double *res, double **mat, double *vec, int nr, int nc);
 
double *dot_nxm_ptr_1(double *res, double **mat, double *vec, int nr, int nc);
 
void matrix_product(double M[4][4], double v[4], double Mv[4]);
 
void matrix_product_0(double **M, double *v, double *Mv, int nr, int nc);
 
void matrix_product_1(double **M, double *v, double *v_out, int nr, int nc);
 
void matmul_3x3_arr(double res[3][3], double mat_1[3][3], double mat_2[3][3]);
 
double **matmul_3x3_ptr(double **res, double **mat_1, double **mat_2);
 
void matmul_4x4_arr(double res[4][4], double mat_1[4][4], double mat_2[4][4]);
 
double **matmul_4x4_ptr(double **res, double **mat_1, double **mat_2);
 
void doublematrix_product(double M1[4][4], double M2[4][4], double M[4][4]);
 
void doublematrix_product_0(double **M1, int nb_row_M1, int nb_col_M1, double **M2, int nb_col_M2, double **M);
 
void doublematrix_product_1(double **M1, int nb_row_M1, int nb_col_M1, double **M2, int nb_col_M2, double **M);
 
int rotation_matrix(int type, double angle, double R[4][4]);
 
int rotation_matrix_4x4_arr(int type, double angle, double R[4][4]);
 
int rotation_matrix_4x4_ptr(int type, double angle, double** R);
 
int rotation_matrix_3x3_arr(int type, double angle, double R[3][3]);
 
int rotation_matrix_3x3_ptr(int type, double angle, double** R);
 
int** get_imat_0(int nb_r, int nb_c);
int** get_imat_1(int nb_r, int nb_c);
 
void free_imat_0(int** mat);
void free_imat_1(int** mat);
 
void copy_imat_0(int** tab_src, int** tab_dest, int nb_r, int nb_c);
 
 
void print_imat_0(int** mat, int nb_r, int nb_c);
 
 
double** get_dmat_0(int nb_r, int nb_c);
double** get_dmat_1(int nb_r, int nb_c);
double** get_contdmat_1(int nb_r, int nb_c);
 
void free_dmat_0(double** mat);
void free_dmat_1(double** mat);
 
void copy_3x3_arr(double res[3][3], double src[3][3]);
 
double **copy_3x3_ptr(double **res, double **src);
 
void copy_4x4_arr(double res[4][4], double src[4][4]);
 
double **copy_4x4_ptr(double **res, double **src);
 
 
void copy_dmat_0(double** tab_src, double** tab_dest, int nb_r, int nb_c);
 
void copy_dmat_1(double** src, double** dest, int x, int y);
 
double **re_copy_dmat_0(double **src, int s_nx, int s_ny, double **dest, int d_nx, int d_ny);
 
double **re_copy_dmat_1(double **src, int s_nx, int s_ny, double **dest, int d_nx, int d_ny);
 
void transpose_dmat_0(double** tab_src, double** tab_dest, int nb_r, int nb_c);
 
void transpose_dmat_1(double** tab_src, double** tab_dest, int x, int y);
 
void print_dmat_0(double** mat, int nb_r, int nb_c);
void print_format_dmat_0(double** mat, int nb_r, int nb_c, char* format);
 
int read_dmat_0(double** mat, int nb_r, int nb_c, const char* name);
 
double** load_dmat_0(int nb_r, int nb_c, char* name);
 
int save_dmat_0(double** mat, int nb_r, int nb_c, char* name);
 
int save_format_dmat_0(double** mat, int nb_r, int nb_c, char* name, char* format);
 
int code_dmat_0(FILE *file_out, double **values, const char *name, int n_row, int n_col);
 
int code_dmat_1(FILE *file_out, double **values, const char *name, int n_row, int n_col);
 
int slct_dmat_0(double** tab_src, int nb_r, int nb_c, double** tab_out, int l_vec, int* vec);
 
int slctr_dmat_0(double** tab_src, int nb_r, int nb_c, double** tab_dest, int l_vec, int* vec);
 
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * SETTING VALUES IN MATRICES (ZEROS, IDENTITY...)                            *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
void zeros_dmat_0(double** mat, int nb_r, int nb_c);
 
int set_diag_dmat_0(double** mat, int size, double value);
 
int set_identity_dmat_0(double** mat, int size);
 
double **identity_dmat_3x3_ptr(double** mat);
 
double **identity_dmat_4x4_ptr(double** mat);
 
int identity_dmat_3x3_arr(double mat[3][3]);
 
int identity_dmat_4x4_arr(double mat[4][4]);
 
void mult_dmat_0(double** A, double** B, double** C, int n1, int n2, int n3);
 
void sum_dmat_0(double** A, double** B, double** C, int n1, int n2);
 
void diff_dmat_0(double** A, double** B, double** C, int n1, int n2);
 
void opposite_dmat_0(double** A, int n1, int n2);
 
void readmatrix(double** matrix, int* n);
 
int get_dmatfiles_size(const char* fileName, int* n_row, int* n_col);
 
void update_initzeros(int* initzeros, double** matrix, int* n);
 
 
void arrange_matrix(double** matrix, int* n, int* initzeros);
 
void scale_matrix(double** matrix, int* n, int* initzeros);
 
 
void copy_array_dmat_1(double src[4][4], double** dest);
 
int same_dmat_0(double **a, double **b, int x, int y);
 
#ifdef __cplusplus
}
#endif
 
/*--------------------*/
#endif