mbs_1D_array.h

Go to the documentation of this file.

 
#ifndef MBS_1D_ARRAY_h
#define MBS_1D_ARRAY_h
 
#include <stdio.h>
#ifdef __cplusplus
extern "C" {
#endif
 
/* Functions related to arrays of doubles */
double *mbs_linspace_0(double start, double stop, int num);
 
double *mbs_linspace_1(double start, double stop, int num);
double *mbs_arange_0(double start, double stop, double step, int with_end, int *size);
 
int *mbs_range_0(int start, int stop, int *size);
 
int *mbs_range_1(int start, int stop, int *size);
 
double *mbs_drand_0(int num, double min, double max);
 
double *mbs_drand_1(int num, double min, double max);
 
int get_dinterval_binary_0(double *array, int size, double value, int *index, int lim_check);
 
int get_dinterval_binary_1(double *array, int size, double value, int *index, int lim_check);
 
int get_dinterval_binary_from_index_0(double *array, int size, double value, int *index, int lim_check, int verbose);
 
int get_dinterval_binary_from_index_1(double *array, int size, double value, int *index, int lim_check, int verbose);
 
int mbs_argmin_dvec_0(double *vec, int size);
 
int mbs_argmin_dvec_1(double *vec, int size);
 
/* Functions related to arrays of integers */
int save_ivec_0(int *vec, int size,char *name, int row);
 
int save_ivec_1(int *vec, int size,char *name, int row);
 
double dot_dvec_3(double v1[3], double v2[3]);
 
double dot_dvec_4(double v1[4], double v2[4]);
 
double dot_dvec_0(double *v1, double *v2, int size);
 
double dot_dvec_1(double *v1, double *v2, int size);
 
double scalar_product(double v1[4], double v2[4]);
 
double scalar_product_0(double* v1, double* v2, int n);
 
double scalar_product_1(double* v1, double* v2, int n);
 
double *add_dvec_4(double res[4], double v1[4], double v2[4]);
 
double *add_dvec_3(double res[3], double v1[3], double v2[3]);
 
double *add_dvec_0(double *res, double *v1, double *v2, int size);
 
double *add_dvec_1(double *res, double *v1, double *v2, int size);
 
void vector_sum(double v1[4], double v2[4], double v_dest[4]);
 
void sum_dvec_0(double *v1, double *v2, int size, double *v_dest);
 
double *subtract_dvec_4(double res[4], double v1[4], double v2[4]);
 
double *subtract_dvec_3(double res[3], double v1[3], double v2[3]);
 
double *subtract_dvec_0(double *res, double *v1, double *v2, int size);
 
double *subtract_dvec_1(double *res, double *v1, double *v2, int size);
 
void vector_diff(double v1[4], double v2[4], double v_dest[4]);
void diff_dvec_0(double *v1, double *v2, int size, double *v_dest);
 
void cross_product(double v1[4], double v2[4], double v_dest[4]);
 
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * MULTIPLICATION/DIVISION BY SCALAR                                           *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
double *multiply_dvec_3(double res[3], double val, double vec[3]);
 
double *multiply_dvec_4(double res[4], double val, double vec[4]);
 
double *multiply_dvec_0(double *res, double val, double *vec, int size);
 
double *multiply_dvec_1(double *res, double val, double *vec, int size);
 
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * ELEMENT-WISE MULTIPLICATION                                                 *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
double *multiply_dvec_dvec_3(double res[3], double vec_1[3], double vec_2[3]);
 
double *multiply_dvec_dvec_4(double res[4], double vec_1[4], double vec_2[4]);
 
double *multiply_dvec_dvec_0(double *res, double *vec_1, double *vec_2, int size);
 
double *multiply_dvec_dvec_1(double *res, double *vec_1, double *vec_2, int size);
 
void number_product(double s, double v1[4], double v_dest[4]);
 
// integer related functions
int* get_ivec_0(int l_v);
int* get_ivec_1(int l_v);
void free_ivec_0(int* vec);
void free_ivec_1(int* vec);
 
void copy_ivec_0(int* vec_src, int* vec_dest, int l_v);
void copy_ivec_1(int* vec_src, int* vec_dest, int l_v);
 
int *re_copy_ivec_0(int *src, int s_nx, int *dest, int d_nx);
 
int *re_copy_ivec_0(int *src, int s_nx, int *dest, int d_nx);
 
void print_ivec_0(int* vec, int l_v);
void print_ivec_1(int* vec);
 
int code_ivec_0(FILE *file_out, int *values, const char *name, int size);
 
int code_ivec_1(FILE *file_out, int *values, const char *name, int size);
 
 
void sort_ivec_0(int* vec_src, int* vec_dest, int l_v);
 
void sort_dvec_0(double* vec_src, double* vec_dest, int l_v);
 
void sort_ivec_1(int* vec_src, int* vec_dest, int l_v);
void sort_inplace_ivec_1(int* vec, int l_v);
void f0123_ivec_0(int* vec, int l_v);
void conc_ivec_0(int* vec1_src, int l_v1, int* vec2_src, int l_v2, int* vec_dest);
void conc_ivec_1(int* vec1_src, int l_v1, int* vec2_src, int l_v2, int* vec3);
 
int slct_ivec_0(int* vec1_src, int l_v1, int* vec_ind_src, int l_v2, int* vec1_dest);
 
int find_ivec_0(int* vec, int l_v, int f);
 
int find_dvec_0(double* vec, int l_v, double f);
 
int find_ivec_1(int* vec, int l_v, int f);
 
int same_ivec_0(int* v1, int* v2, int size);
 
int same_ivec_1(int* v1, int* v2);
 
// double related functions
double* get_dvec_0(int l_v);
double* get_dvec_1(int l_v);
 
void free_dvec_0(double* vec);
void free_dvec_1(double* vec);
 
double *copy_dvec_0(double* vec_src, double* vec_dest, int l_v);
double *copy_dvec_1(double* vec_src, double* vec_dest);
 
double *convert_dvec_0_to_1(double *src, int size, int free_src);
 
double *convert_dvec_1_to_0(double *src, int size, int free_src);
 
double *re_copy_dvec_0(double *src, int s_nx, double *dest, int d_nx);
double *re_copy_dvec_1(double *src, int s_nx, double *dest, int d_nx);
 
void print_dvec_0(double* vec, int nb_r);
 
void print_format_dvec_0(double* vec, int nb_r, char* format);
 
void print_dvec_1(double* vec);
 
int code_dvec_0(FILE *file_out, double *values, const char *name, int size);
 
int code_dvec_1(FILE *file_out, double *values, const char *name, int size);
 
void save_dvec_0(double* vec, int nb_r, char* name);
 
void pick_and_place_dvec_1(double* src, int* index, int n, double* dest);
 
void pick_and_place_dvec_0(double* src, int* index, int n, double* dest);
 
void slct_dvec_1(double* vec1_src, int* vec_ind_src, int l_v, double* vec3);
 
int slct_dvec_0(double* vec1_src, int l_v1, int* vec_ind_src, int l_v2, double* vec_dest);
 
int any_dvec_0(double* vec, int l_v);
 
void value_dvec_0(double value, double* vec, int l_v);
void value_dvec_1(double value, double* vec);
 
void zeros_dvec_3(double vec[3]);
 
void zeros_dvec_4(double vec[4]);
 
void zeros_dvec_0(double* vec, int l_v);
void zeros_dvec_1(double* vec);
 
void opposite_dvec_0(double* vec, int n);
 
void opposite_dvec_1(double* vec);
 
int cmp_dvec_0(double* v1, double* v2, int size);
 
int same_dvec_0(double* v1, double* v2, int size);
 
int same_dvec_1(double* v1, double* v2);
 
int max_dvec_0(double* vec, int size);
 
int max_dvec_1(double* vec);
 
/********************************************
 *          NORM-related functions          *
 ********************************************/
 
double norm(double v[4]);
 
void normalize(double v[4], double vn[4]);
 
double norm_dvec_3(double v[3]);
 
double norm_dvec_4(double v[4]);
 
double norm_dvec_0(double* vec, int l_v);
double norm_dvec_1(double* vec, int l_v);
void normalize_dvec_0(double* vec, double* vn, int l_v);
void normalize_dvec_1(double* vec, double* vn, int l_v);
 
double norminf_vector_1(double *v, int n);
 
 
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * COMPUTATION IN SPACE                                                        *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
double *projection_dvec_3(double res[3], double vec[3], double axis[3]);
 
double *projection_dvec_4(double res[4], double vec[4], double axis[4]);
 
double distance_dvec_3(double pt_1[3], double pt_2[3]);
 
double distance_dvec_4(double pt_1[4], double pt_2[4]);
 
double *mean_dvec_3(double res[3], double pt_1[3], double pt_2[3]);
 
double *mean_dvec_4(double res[4], double pt_1[4], double pt_2[4]);
 
double *mean_n_dvec_3(double res[3], double *vecs[], int n_vecs);
 
double *mean_n_dvec_4(double res[4], double *vecs[], int n_vecs);
 
#ifdef __cplusplus
}
#endif
 
#endif