elementaryFunctions.h

Go to the documentation of this file.

//********************************************************************************************************
// code:                          ###  ###  #####   ####  ##  ##
//                       ##  ##   ########  ##     ##  ## ##  ##
//                       ##  ##   ## ## ##  ###    ##     ######
//                       ##  ##   ##    ##  ##     ##  ## ##  ##
//                       #####    ##    ##  #####   ####  ##  ##
//                       ##
//
// name:           elementaryFunctions.h
// author(s):      Jan Novak
// language:       C, C++
// license:        This program is free software; you can redistribute it and/or modify
//                 it under the terms of the GNU Lesser General Public License as published by
//                 the Free Software Foundation; either version 2 of the License, or
//                 (at your option) any later version.
//
//                 This program is distributed in the hope that it will be useful,
//                 but WITHOUT ANY WARRANTY; without even the implied warranty of
//                 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//                 GNU Lesser General Public License for more details.
//
//                 You should have received a copy of the GNU Lesser General Public License
//                 along with this program; if not, write to the Free Software
//                 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//********************************************************************************************************
#ifndef MUMECH_ELEMENTARY_FUNCTIONS_H
#define MUMECH_ELEMENTARY_FUNCTIONS_H

#include <time.h>
#include <stdio.h>
#include <string.h>


// print flag
#define _MATHEMATICA_SYNTAX_   0
#define _STANDARD_SYNTAX_      1


namespace mumech {


//macros and type definitions
//---------------------------

//open file manipulation macros
typedef enum { _READ_, _WRITE_, _ADD_ } file_mode;



// *******************************************************************************************************
// /**                            Operations with arrays of chars                                      **/
// /** @name                       ***   VARIOUS FUNCTIONS   ***                                       **/
// ***************************************************|***************************************************
// @{

//********************************************************************************************************
//function gives the position of given 'double' @number in given @column of 2D array.
//Function explores the numbers in column from 0-zero until @rozsah increment
//int GetPosition( double ** array, double number, int column, int rozsah );
//********************************************************************************************************

//********************************************************************************************************
//function prints the iteration progress to console in 'per-cent'
void PrintProgress( double procento, int incr );
//********************************************************************************************************
//function prints the iteration progress to console, function prints a mark '\/'
void PrintProgress( clock_t * p_time );

double giveVolumeEllipsoid (double a, double b, double c);

double give_curvature (double x, double a, double b);

// Inverse hyperbolic cosine
double acosh(double x);

// @}


// *******************************************************************************************************
// /**                          Operations with file descriptors                                       **/
// /** @name                      ***   FILE PROCESSING   ***                                          **/
// ***************************************************|***************************************************
// @{

void OpenFile( FILE **file, char *name, const char mode[] );
void OpenFile( FILE* &file, char name[], int mode );
void CloseFile( FILE *file );

void GoToEndOfLine( FILE * fr );

void LatexPreambule( FILE * fw );
void LatexEnd( FILE * fw );

//file_descriptor WriteTmp( char * buffer, size_t length )

// @}


// *******************************************************************************************************
// /**                            Operations with arrays of chars                                      **/
// /** @name                       ***   STRING PROCESSING   ***                                       **/
// ***************************************************|***************************************************
// @{

int GetRangeOfFileRows(char * p_name);
int GetRangeOfFileColumns(char * p_name);
int GetRangeOfFileColumns_ii(char * p_name);

// @}


// *******************************************************************************************************
// /**                        Operations with 1d arrays of various length                              **/
// /** @name                     ***   GENERAL VECTOR OPERATIONS   ***                                 **/
// ***************************************************|***************************************************
// @{

inline bool*   Allocate1Dbz  (long d1) { bool   *a = new bool  [d1];  memset (a, 0, d1*sizeof(bool  ));  return a; }
inline bool**  Allocate1Dbp  (long d1) { bool  **a = new bool* [d1];  memset (a, 0, d1*sizeof(bool* ));  return a; }


inline int*      Allocate1Di   (long d1) { int      *a = new int     [d1];                                       return a; }

inline double*   Allocate1Dd   (long d1) { double   *a = new double  [d1];                                       return a; }
inline double*   Allocate1Ddz  (long d1) { double   *a = new double  [d1];  memset (a, 0, d1*sizeof(double  ));  return a; }
inline double**  Allocate1Ddp  (long d1) { return (double**) memset (new double* [d1], 0, d1*sizeof(double* )); }
inline double*** Allocate1Ddpp (long d1) { double ***a = new double**[d1];  memset (a, 0, d1*sizeof(double**));  return a; }


inline void CleanVector (double *a, long n) { memset (a, 0, n * sizeof(double)); }
inline void CleanVector (int    *a, long n) { memset (a, 0, n * sizeof(int)   ); }
inline void CleanVector (long   *a, long n) { memset (a, 0, n * sizeof(long)  ); }

//void CleanString( char * p, int n ) { zkontrolovat, jestli nemuzu pouzit memset  p_string_name += n;   while (n--) p[n] = '\0';}

inline double GiveSumMembersVector (const double *a, long n) { double s=0.0;  while (n--) s+= *(a++);  return s; }


inline void CopyVector (const double *src, double *dest, long n) { if(src==dest) return;  memcpy(dest, src, n * sizeof(double)); }
inline void CopyVector (const long   *src, long   *dest, long n) { if(src==dest) return;  memcpy(dest, src, n * sizeof(long  )); }
inline void CopyVector (const int    *src, int    *dest, long n) { if(src==dest) return;  memcpy(dest, src, n * sizeof(int   )); }

inline void AddVector (const double *a, double *b, long n) { while (n--)  b[n] += a[n]; }
inline void AddVector (const int    *a, int    *b, long n) { while (n--)  b[n] += a[n]; }

inline void SubtractVector     (const double *a, double *b, long n) { while (n--)  b[n] -= a[n]; }

inline void SubtractTwoVectors (const double *v1, const double *v2, double *answer, long n) { while (n--) answer[n] = v1[n] - v2[n]; }

inline void AddScalarToVector (long s, long *v, long n) { while (n--)  v[n] += s; }

inline void SumTwoVectors (const double *v1, const double *v2, double *answer, long n) { while (n--) answer[n] = v1[n] + v2[n]; }


inline void AddVectorMultipledBy (double mlt, const double *a, double *b, long n) { while (n--)  b[n] += mlt * a[n]; }

inline void DivideVector   (double *a, long n, double val) { while (n--)  a[n] /= val; }

inline void MultiplyVector (double *a, long n, double val) { while (n--)  a[n] *= val; }

double give_VectorVectorProduct (const double *v1, const double *v2, long n);

double give_quadNormTwoVectors   (const double *v1, const double *v2, int n);

//function initializes a 2D 'double' array from a given file
void ReadDataToArray( double ** p_array, char * p_file_name );
//function initializes a 3D 'double' array by values from a given file
void ReadDataTo3DArray( double *** p_array, char * p_file_name, int no_fields, int no_rows,
            int no_columns );
//function initializes a 3D 'int' array by values from a given file
void ReadDataToArray( int ** p_array, char * p_file_name );
//function initializes an 'int' vector by values from a given file
void ReadDataToVector( int * p_array, char * p_file_name );


double giveVectorLength (double *point_1, double *point_2);

double giveVectorLength (double rx, double ry, double rz);

bool isNumberPresentInVector( int number, int * vector, int range );


// @}


// *******************************************************************************************************
// /**                       Operations with 2d, 3d, 4d arrays of various sizes                        **/
// /** @name                       ***   GENERAL ARRAY OPERATIONS   ***                                **/
// ***************************************************|***************************************************
// @{

double** AllocateArray2D (long d1, long d2);
void AllocateArray2D (double **&array, long d1, long d2);

// /// Function allocates a 2D 'double' d1xd2 array by 'new' command. First dimension is 'all', second dim only one i1-th.
// double** AllocateArray2Dao (long d1, long d2, long i1);
// /// Function allocates a 2D 'double' array by 'new' command.
// void AllocateArray2Dao (double **&array, long d1, long d2, long i1);

inline void DeleteArray2D (bool    **array, long d1)          { if (array == NULL) return;  while (d1--) delete [] array[d1];           delete [] array;  array = NULL; }
inline void DeleteArray2D (double  **array, long d1)          { if (array == NULL) return;  while (d1--) delete [] array[d1];           delete [] array;  array = NULL; }
inline void DeleteArray3D (double ***array, long d1, long d2) { if (array == NULL) return;  while (d1--) DeleteArray2D(array[d1], d2);  delete [] array;  array = NULL; }


inline void CleanArray2D (int    **a, long rows, long columns) { while (rows--)  memset (a[rows], 0, columns * sizeof(int   )); }
inline void CleanArray2d (double **a, long rows, long columns) { while (rows--)  memset (a[rows], 0, columns * sizeof(double)); }

//void CopyArray2D (const double  **src, double  **dest,  int d1,  int d2) { true;}
void CopyArray2D (const double* const* src, double** dest, long d1, long d2);


void CopyArray3D (const double ***src, double ***dest, long d1, long d2, long d3);

void AddArray2D (const double* const* src, double** dest, long d1, long d2);
void AddArray3D (double ***src, double ***dest, long d1, long d2, long d3);

void DivideArray2D (double** a, double val, long d1, long d2);



void SubtractTwoArrays2D (const double* const* a1, const double* const* a2, double **answer, long d1, long d2);


void giveInverseMatrix2x2 (double *answer, const double *m);
void giveInverseMatrix3x3 (double *answer, const double *m);

void giveInverseMatrix3x3to5  (double *answer, const double *m);
void giveInverseMatrix6x6to12 (double *answer, const double *m);


inline double GiveSumMembersArray2D (const double **a, long d1, long d2) { double s=0.0;  while (d1--)  s += GiveSumMembersVector(*(a++), d2); return s; }

inline void copyMatrix_1Dto2D (const double *v, double **m, long n) { for (long i=0; i<n; i++) memcpy (m[i], v+i*n, n * sizeof(double)); }

inline void copyMatrix_2Dto1D (const double* const* m, double *v, long n) { for (long i=0; i<n; i++)  memcpy (v+i*n, m[i], n * sizeof(double)); }

inline void giveUnitMatrix2x2 (double *m) { m[1] = m[2] = 0.0;  m[0] = m[3] = 1.0; }
inline void giveUnitMatrix3x3 (double *m) { m[1] = m[2] = m[3] = m[5] = m[6] = m[7] = 0.0;  m[0] = m[4] = m[8] = 1.0; }



void giveMatrixVectorProduct (const double *mtrx, const double *vect, double *resVect, long n);

void giveMatrixMatrixProduct (const double *mtrx1, const double *mtrx2, double *resMtrx, long n);


void giveTransposedMatrix( const double * mtrx, double * T_mtrx, int n );

void printMatrix( double * mtrx, int n, const char * notice );

void printMatrix( double ** mtrx, int n, const char * notice );

void printVector( double * vect, int n, const char * notice );

void printVector( int * vect, int n, const char * notice );

void printVectorRowForm( double * vect, int n, const char * notice );

void printVectorRowForm( int * vect, int n, const char * notice );


// @}


} // end of namespace mumech

#endif

/*end of file*/