elementaryFunctions.cpp

Go to the documentation of this file.

//********************************************************************************************************
// code:                          ###  ###  #####   ####  ##  ##
//                       ##  ##   ########  ##     ##  ## ##  ##
//                       ##  ##   ## ## ##  ###    ##     ######
//                       ##  ##   ##    ##  ##     ##  ## ##  ##
//                       #####    ##    ##  #####   ####  ##  ##
//                       ##
//
// name:           elementaryFunctions.cpp
// 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.
//********************************************************************************************************

#include <math.h>
#include "macros.h"
#include "elementaryFunctions.h"
#include "types.h"

#include "gelib.h"

#include <string.h>


namespace mumech {



// *******************************************************************************************************
// /**                            Operations with arrays of chars                                      **/
// /**                             ***   VARIOUS FUNCTIONS   ***                                       **/
// ***************************************************|***************************************************

//int GetPosition( double ** array, double number, int column, int rozsah )
//{
//  int i = 0;
//  //int position = 0;
//  for( i = 0; i < rozsah; i++ ){
//    if( ABS( array[i][column] - number ) < MACHINE_EPS ){
//      return( i );
//    }else ;
//  }
//  _warningg( "GetPosition: searched number not found, FALSE returned\n");
//  return( FALSE );
//}//end of function: GetPosition( )


//********************************************************************************************************
// description: function prints the iteration progress to console in 'per-cent'
// last edit:   04.02.2007
//--------------------------------------------------------------------------------------------------------
// note:        @incr - the increment of a loop which progress to be print
//              @procento = ( double ) iter_max/100, where iter_max is the maximum nuber of loop increment
//              e. g.: for( incr = 0; incr < iter_max, incr++ )
//              THIS FUNCTION IS GENERALLY TIME CONSUMING, useful just for small loops or
//              debuging purposes
//********************************************************************************************************
void PrintProgress( double procento, int incr )
{
  printf("%3.0lf%%\b\b\b\b", ( ( double ) incr / procento ) );
  return ;
}//end of function: PrintProgress( )

//********************************************************************************************************
// description: function prints the iteration progress to console, function prints a mark '\/'
// last edit:   04.02.2007
//--------------------------------------------------------------------------------------------------------
// note:        function requires the allocation of a pinter to 'time', i.e.:
//              time_t * p_time;
//              p_time = ( clock_t * ) malloc( sizeof( clock_t ) );
//              The syntax of the function in a programm then is as follows:
//              * p_time = clock();
//              PrintProgress( p_time );
//********************************************************************************************************
void PrintProgress( clock_t * p_time )
{
  double timer = 0.;

  timer = * p_time / ( double ) CLOCKS_PER_SEC;
  if( timer > ( 2/24.) ) printf( "-\b" ); else ;
  if( timer > ( 4/24.) ) printf( "\\\b" ); else ;
  if( timer > ( 6/24.) ) printf( "|\b" ); else ;
  if( timer > ( 8/24.) ){
    printf( "/\b" );
    * p_time = 0;
  }else ;
  return ;
}//end of function: PrintProgress( )


double giveVolumeEllipsoid (double a, double b, double c)
{
  return ( 4. * PI * a * b * c / 3. );
}

double give_curvature (double x, double a, double b)
{
return b/a + (1.0-b/a) / (0.5*PI) * x;
}

double acosh(double x)
{
  return log(x + sqrt(x + 1.0) * sqrt(x - 1.0));
}




// *******************************************************************************************************
// /**                          Operations with file descriptors                                       **/
// /**                            ***   FILE PROCESSING   ***                                          **/
// ***************************************************|***************************************************


void OpenFile( FILE **file, char *name, const char mode[] )
{
  if ((*file = fopen(name, mode)) == NULL){
    FileError("open", name);
  }else ;

  return ;
}

void OpenFile( FILE* &file, char name[], int mode )
{
  switch( mode ){
  case _READ_ :
    file = fopen( name, "r" );
    break;
  case _WRITE_ :
    file = fopen( name, "w" );
    break;
  case _ADD_ :
    file = fopen( name, "a" );
    break;
  default:
    _errorr("OpenFile: ERROR: no valid opening mode selected\n");
    break;
  }

  if (file == NULL ){
    FileError("open", name);
  }

  return;
}

void CloseFile( FILE *file )
{
  if ((fclose(file)) == EOF){
    FileError("close", "");
  }else ;

  return ;
}

void GoToEndOfLine( FILE * fr )
{
  int c = 0;

  while( ( c = getc( fr ) ) != '\n' ){
    ;
  }
}

void LatexPreambule( FILE * fw )
{
  fprintf( fw, "\\documentclass[a4paper,11pt]{article}\n");
  fprintf( fw, "\\usepackage[pdftex]{graphicx}\n" );
  fprintf( fw, "\\usepackage{fullpage}\n" );
  fprintf( fw, "\\usepackage{latexsym}\n" );
  fprintf( fw, "\n\n\\begin{document}\n\n" );
  fprintf( fw, "\\renewcommand{\\arraystretch}{1.2}\n" );

  return ;
}

void LatexEnd( FILE * fw )
{
  fprintf( fw, "\n\n\\end{document}\n" );
  return ;
}

//help:

//file_descriptor WriteTmp( char * buffer, size_t length )
//{
//  errol;
//   /* Vytvori nazev souboru a samotny soubor. XXXXXX bude
//    * prepsano nejakymi znaky, aby bylo jmeno unikatni. */
//   char temp_filename[] = "/tmp/temp_file.XXXXXX";
//   int fd = mkstemp( temp_filename );
//   /* Zrusi jmeno souboru v filesystemu, az se
//    * uzavre deskriptor souboru soubor se smaze. */
//   unlink( temp_filename );
//   /* Zapise velikost zapisovanych dat v bytech. */
//   write( fd, &length, sizeof( length ) );
//   /* Nyni zapise samotna data. */
//   write( fd, buffer, length );
//   /* Vrati deskriptor souboru docasneho souboru */
//   return( fd );
//}


// *******************************************************************************************************
// /**                            Operations with arrays of chars                                      **/
// /**                             ***   STRING PROCESSING   ***                                       **/
// ***************************************************|***************************************************

//********************************************************************************************************
// description: function gives the number of lins of a file
// last edit:   30.10.2004
//--------------------------------------------------------------------------------------------------------
// note:        @name - pointer to the string containing the name of a file
//********************************************************************************************************
int GetRangeOfFileRows(char * p_name)
{
  FILE * fr;
  OpenFile (&fr, p_name, "r");
  int c = 0, i = 0;
  while ((c = getc(fr)) != EOF){
    if(c == '\n'){
      i++;
    }
  }
  CloseFile (fr);
  return(i);
}//end of function: GetRangeOfFileRows( )

//********************************************************************************************************
// description: function gives the number columns of the file such as is not necessarilly
//              structured as a table
// last edit:   3.11.2004, 18.11.2009
//--------------------------------------------------------------------------------------------------------
// note:        @p_name - pointer to the string containing the name of a file
//********************************************************************************************************
int GetRangeOfFileColumns(char * p_name)
{
  FILE * fr;
  int i = 0, rows = 0;
  double value = 0.;

  OpenFile (&fr, p_name, "r");

  while ((fscanf(fr, "%lf", &value)) == 1){
      i++;
  }

  rows = GetRangeOfFileRows(p_name);

  if( rows == 0 ){
    _errorr("GetRangeOfFileColumns: no lines in tested file\n");
  }else ;

  CloseFile (fr);
  return (int) (i/rows);
}//end of function: GetRangeOfFileColumns( )

//********************************************************************************************************
// description: function gives the number columns of a file structured as a table
// last edit:   13.04.2006
//--------------------------------------------------------------------------------------------------------
// note:        Contrary to a prevois function 'GetRangeOfFileColumns( )', this function counts
//              and returns just the number of entris in the first row of the @p_name file
//********************************************************************************************************
int GetRangeOfFileColumns_ii(char * p_name)
{
  FILE * fr, * fw;
  int i = 0, c = 0;
  double value = 0.;
  char tmp_file[] = "tmp_fileXXXXXX";

  OpenFile (&fr, p_name, "r");
  //mkstemp( tmp_file );
  //thrue uot the blank characters
  while( ( c = getc(fr) ) == ' ' || c == '\t' || c == '\n'){
    ;
  }

  OpenFile (&fw, tmp_file, "w");
  //writing of a temporary file
  putc( c, fw );
  while( ( c = getc(fr) ) != '\n' ){
    putc( c, fw );
  }

  CloseFile (fr);
  CloseFile (fw);

  //reading of double values in the first line
  OpenFile(&fr, tmp_file, "r");
  while ((fscanf(fr, "%lf", &value)) == 1){
    i++;
  }

  CloseFile (fr);
  remove( tmp_file );

  return ( i );
}//end of function: GetRangeOfFileColumns_ii( )




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

double give_VectorVectorProduct (const double *v1, const double *v2, long n)
{
  double prd = 0.0;
  while (n--)
    prd += v1[n] * v2[n];
  
  return prd;
}
double give_quadNormTwoVectors (const double *v1, const double *v2, int n)
{
  double norm = 0.0;
  while (n--)
    norm += SQR( v1[n] - v2[n] );

  return sqrt( norm );
}

void ReadDataToArray( double ** p_array, char * p_file_name )
{
  FILE * fr;
  int i = 0, j = 0, rows = 0, columns= 0;

  rows = GetRangeOfFileRows(p_file_name);
  columns = GetRangeOfFileColumns_ii(p_file_name);

  OpenFile (&fr, p_file_name, "r");

  for(i = 0; i < rows; i++){
    for(j = 0; j < columns; j++){
      fscanf(fr, "%lf", &p_array[i][j]);
    }
  }
  CloseFile (fr);
}

void ReadDataTo3DArray( double *** p_array, char * p_file_name, int no_fields, int no_rows, int no_columns )
{
  FILE * fr;
  int i = 0, j = 0, k = 0;

  OpenFile(&fr, p_file_name, "r");

  for(i = 0; i < no_fields; i++){
    for(j = 0; j < no_rows; j++){
      for(k = 0; k < no_columns; k++){
        fscanf(fr, "%lf", &p_array[i][j][k]);
      }
    }
  }
  CloseFile(fr);
}

void ReadDataToArray( int ** p_array, char * p_file_name )
{
  FILE * fr;
  int i = 0, j = 0, rows = 0, columns= 0;

  rows = GetRangeOfFileRows(p_file_name);
  columns = GetRangeOfFileColumns(p_file_name);

  OpenFile (&fr, p_file_name, "r");

  for(i = 0; i < rows; i++){
    for(j = 0; j < columns; j++){
      fscanf(fr, "%d", &p_array[i][j]);
    }
   }
  CloseFile (fr);
}

void ReadDataToVector( int * p_array, char * p_file_name )
{
  FILE * fr;
  int i = 0, rows = 0;

  rows = GetRangeOfFileRows(p_file_name);

  OpenFile (&fr, p_file_name, "r");

  for(i = 0; i < rows; i++){
    fscanf(fr, "%d", &p_array[i]);
  }

  CloseFile (fr);
}

double giveVectorLength (const double *point_1, const double *point_2)
{
  double length = 0.;
  
  length = SQR( point_1[0] - point_2[0] )
         + SQR( point_1[1] - point_2[1] )
         + SQR( point_1[2] - point_2[2] );
  
  return sqrt( length );
}

double giveVectorLength (double rx, double ry, double rz)
{
  double length = 0.;
  
  length = SQR( rx ) + SQR( ry ) + SQR( rz );
  
  return sqrt( length );
}


bool isNumberPresentInVector (int number, int *vect, int range)
{
  while (range--)
    if (vect[range] == number)
      return true;
  
  return false;
}



//   //  ** ALLOCATION OF ARRAYS BY MALLOC FUNCTION. PLEASE, USE FUNCTION AllocateVector AND AllocateArrays INSTEAD.
//   //  ** Allocation by 'new' is exclusively adopted to avoid mismatch between malloc and new.
//   
//   
//   //********************************************************************************************************
//   // description: function allocates a 'double' vector
//   // last edit:   25.1.2007, 18.11.2009
//   //********************************************************************************************************
//   void CreateVector( double* &vector, int range )
//   {
//     int i = 0;
//   
//     vector = ( (double *) malloc(range * sizeof(double)) );
//   
//     if( vector == NULL){
//       _errorr( "CreateVector: Alocation of 'double' vector failed\n");
//     }else;
//   
//     for(i = 0; i < range; i++){
//       vector[i] = 0.;
//     }
//   
//     return ;
//   }//end of function: CreateVector( )
//   
//   

// //********************************************************************************************************
// // description: function deletes a 2D 'int' array
// // last edit:   25.1.2007, 18.11.2009
// //********************************************************************************************************
// void DeleteArray( int ** array, int rows )
// {
//   for( int i = 0; i < rows; i++ ){
//     free( ( void * )array[i] );
//   }
//   free( ( void ** )array );
//   array = NULL;
//   return ;
// }//end of function: DeleteArray( )

// //********************************************************************************************************
// // description: function realocates the (extends/cuts) alrady allocated memory to 'double'
// // last edit:   25.1.2007, 18.11.2009
// //--------------------------------------------------------------------------------------------------------
// // note:        @howmany - howmany members will be attached to existing vector
// //********************************************************************************************************
// void ExtendVector( double* &vector, int howmany )
// {
//   // tuto fci nemuzu pouzit
//   errol;
//   
//   
//   vector = ( (double *) realloc( vector, howmany * sizeof( double ) ) );
// 
//   if( vector == NULL){
//     _errorr( "ExtendVector: reallocation of 'double' memory failed\n");
//   }else;
// 
//   return ;
// }//end of function: ExtendVector( )
// 



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

double** AllocateArray2D (long d1, long d2)
{
  double **array = new double*[d1];
  while (d1--)  array[d1] = new double[d2];
  return array;
}
void AllocateArray2D (double **&array, long d1, long d2)
{
  if (array != NULL)  _errorr("allocation of non NULL array");
  array = AllocateArray2D(d1,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)
// {
//   double **array = new double*[d1];
//   memset (array, 0, d1*sizeof(double*));
//   
//   array[i1] = new double[d2];
//   return array;
// }
// /// Function allocates a 2D 'double' array by 'new' command.
// void AllocateArray2Dao (double **&array, long d1, long d2, long i1)
// {
//   if (array != NULL)  _errorr("allocation of non NULL array");
//   array = AllocateArray2D(d1,d2,i1);
// }

void CopyArray2D (const double* const* src, double **dest, long d1, long d2)
{
  long i, j;
  
  for (i=0; i<d1; i++)
    for (j=0; j<d2; j++)
      dest[i][j] = src[i][j];

  // pouzij toto memcpy(b, a, n * sizeof(double)); }
  
}
void CopyArray3D (const double ***src, double ***dest, long d1, long d2, long d3)
{
  long i, j, k;
  
  for (i=0; i<d1; i++)
    for (j=0; j<d2; j++)
      for (k=0; k<d3; k++)
    dest[i][j][k] = src[i][j][k];
  
  // pouzij toto memcpy(b, a, n * sizeof(double)); }

}

void AddArray2D (const double* const* src, double** dest, long d1, long d2)
{
  long i, j;
  
  for (i=0; i<d1; i++)
    for (j=0; j<d2; j++)
      dest[i][j] += src[i][j];
  
}
void AddArray3D (double ***src, double ***dest, long d1, long d2, long d3)
{
  long i, j, k;
  
  for (i=0; i<d1; i++)
    for (j=0; j<d2; j++)
      for (k=0; k<d3; k++)
    dest[i][j][k] += src[i][j][k];
  
}

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

  for (i=0; i<d1; i++)
    for (j=0; j<d2; j++)
      a[i][j] /= val;

}



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

  for (i=0; i<d1; i++)
    for (j=0; j<d2; j++)
      answer[i][j] = a1[i][j] - a2[i][j];
}


void giveInverseMatrix2x2 (double *answer, const double *m)
{
  double det = m[0]*m[3] - m[1]*m[2];

  answer[0] =  m[3] / det;
  answer[1] = -m[1] / det;
  answer[2] = -m[2] / det;
  answer[3] =  m[0] / det;
}

void giveInverseMatrix3x3 (double *answer, const double *m)
{
  double det = m[0]*m[4]*m[8] - m[0]*m[5]*m[7] - m[1]*m[3]*m[8] + m[1]*m[5]*m[6] + m[2]*m[3]*m[7] - m[2]*m[4]*m[6];
  
  answer[0] =  (m[4]*m[8] - m[5]*m[7]) / det;
  answer[1] = -(m[1]*m[8] - m[2]*m[7]) / det;
  answer[2] =  (m[1]*m[5] - m[2]*m[4]) / det;
  
  answer[3] = -(m[3]*m[8] - m[5]*m[6]) / det;
  answer[4] =  (m[0]*m[8] - m[2]*m[6]) / det;
  answer[5] = -(m[0]*m[5] - m[2]*m[3]) / det;
  
  answer[6] =  (m[3]*m[7] - m[4]*m[6]) / det;
  answer[7] = -(m[0]*m[7] - m[1]*m[6]) / det;
  answer[8] =  (m[0]*m[4] - m[1]*m[3]) / det;
}


void giveInverseMatrix3x3to5 (double *answer, const double *m)
{
  giveInverseMatrix2x2 (answer, m);

  answer[4] =  1.0 / m[4];
}
void giveInverseMatrix6x6to12 (double *answer, const double *m)
{
  giveInverseMatrix3x3 (answer, m);

  answer[ 9] =  1.0 / m[ 9];
  answer[10] =  1.0 / m[10];
  answer[11] =  1.0 / m[11];
}




//local constant definitions
#define _at( mtrx, i, j, n )  mtrx[i * n + j] //n - number of rows of the matrix @mtrx


//********************************************************************************************************
// description: function gives the product of a regular matrix with a vector. Both matrix and the vector
//              are saved in 'row-by-row' C arrangement as 1D arrays
// last edit:   27. 11. 2009
// -------------------------------------------------------------------------------------------------------
// note:        @mtrx - '@n x @n' regular matrix
//              @vect - '@n x 1' input vector
//              @resVect - '@n x 1' resulting vector of a product
//              @n - number of rows of a matrix or number of vector entries
//********************************************************************************************************
void giveMatrixVectorProduct (const double *mtrx, const double *vect, double *resVect, long n)
{
  double *auxResVect = NULL;
  
  // in case of in-place product
  if (vect == resVect)  auxResVect = new double[n];
  // in case of out-of-place product
  else                  auxResVect = resVect;
  
  CleanVector (auxResVect, n);
  
  // matrix vector product
  int i, j;
  for (i = 0; i < n; i++)
    for (j = 0; j < n; j++)
      auxResVect[i] += _at( mtrx, i, j, n ) * vect[j];
  
  
  // initialization of resulting vecotor cleaning of allocated memory
  if (vect == resVect) {
    CopyVector (auxResVect, resVect, n);
    delete [] auxResVect;
  }
  else
    auxResVect = NULL;
  
}


void giveMatrixMatrixProduct (const double *mtrx1, const double *mtrx2, double *resMtrx, long n)
{
  if (mtrx1 == mtrx2  ||  mtrx1 == resMtrx  ||  mtrx2 == resMtrx)  errol;
  
  CleanVector(resMtrx, n*n);
  
  long i, j, k;
  for (i = 0; i < n; i++)
    for (j = 0; j < n; j++)
      for (k = 0; k < n; k++)
        _at( resMtrx, i, j, n ) += _at( mtrx1, i, k, n ) * _at( mtrx2, k, j, n );
  
}


void giveTransposedMatrix( const double * mtrx, double * T_mtrx, int n )
{
  //Ts's
  for( int i = 0; i < n; i++ ){
    for( int j = 0; j < n; j++ ){
      _at( T_mtrx, i, j, n ) = _at( mtrx, j, i, n );
    }
  }
}

//********************************************************************************************************
// description: function prints a matrix which is saved in 'row-by-row' C arrangement as 1D array
// last edit:   02. 12. 2009
// -------------------------------------------------------------------------------------------------------
// note:        @mtrx - '@n x @n' regular matrix
//              @n - number of rows of printed matrix
//********************************************************************************************************
void printMatrix( double * mtrx, int n, const char * notice )
{
  printf( "%s", notice );
  for( int i = 0; i < n; i++ ){
    for( int j = 0; j < n; j++ ){
      if( ABS( _at( mtrx, j, i, n ) ) > MACHINE_EPS_PRN ){
    printf( "%.6e ", _at( mtrx, j, i, n ) );
      }
      else{
    printf( "%.6e ", 0. );
      }
    }printf( "\n" );
  }

  return ;
}//end of function: printMatrix( )


//********************************************************************************************************
// description: function prints a matrix which is saved as 2D array
// last edit:   02. 12. 2009
// -------------------------------------------------------------------------------------------------------
// note:        @mtrx - '@n x @n' regular matrix
//              @n - number of rows of printed matrix
//********************************************************************************************************
void printMatrix( double ** mtrx, int n, const char * notice )
{
  printf( "%s", notice );
  for( int i = 0; i < n; i++ ){
    for( int j = 0; j < n; j++ ){
      if( ABS( mtrx[i][j] ) > MACHINE_EPS_PRN ){
    printf( "%.6e ", mtrx[i][j] );
      }
      else{
    printf( "%.6e ", 0. );
      }
    }printf( "\n" );
  }

  return ;
}//end of function: printMatrix( )


//********************************************************************************************************
// description: function prints the vector of double values as column
// last edit:   08. 12. 2009
// -------------------------------------------------------------------------------------------------------
// note:        @vect - '@n x 1' vector
//              @n - number of vector entries
//********************************************************************************************************
void printVector( double * vect, int n, const char * notice )
{
  printf( "%s", notice );
  for( int i = 0; i < n; i++ ){
    if( ABS( vect[i] ) > MACHINE_EPS_PRN ){
      printf( "%.6e\n", vect[i] );
    }
    else{
      printf( "%.6e\n", 0. );
    }
  }

  return ;
}//end of function: printVector( )

//********************************************************************************************************
// description: function prints the vector of integers as column
// last edit:   08. 12. 2009
// -------------------------------------------------------------------------------------------------------
// note:        @vect - '@n x 1' vector
//              @n - number of vector entries
//********************************************************************************************************
void printVector( int * vect, int n, const char * notice )
{
  printf( "%s", notice );
  for( int i = 0; i < n; i++ ){
    printf( "%d\n", vect[i] );
  }

  return ;
}//end of function: printVector( )



//********************************************************************************************************
// description: function prints the vector of double values as row
// last edit:   08. 12. 2009
// -------------------------------------------------------------------------------------------------------
// note:        @vect - '@n x 1' vector
//              @n - number of vector entries
//********************************************************************************************************
void printVectorRowForm( double * vect, int n, const char * notice )
{
  printf( "%s", notice );
  for( int i = 0; i < n; i++ ){
    if( ABS( vect[i] ) > MACHINE_EPS_PRN ){
      printf( "%.6e, ", vect[i] );
    }
    else{
      printf( "%.6e, ", 0. );
    }
  }printf( "\n" );

  return ;
}//end of function: printVectorRowForm( )

//********************************************************************************************************
// description: function prints the vector of integers as row
// last edit:   08. 12. 2009
// -------------------------------------------------------------------------------------------------------
// note:        @vect - '@n x 1' vector
//              @n - number of vector entries
//********************************************************************************************************
void printVectorRowForm( int * vect, int n, const char * notice )
{
  printf( "%s", notice );
  for( int i = 0; i < n; i++ ){
    printf( "%d, ", vect[i] );
  }printf( "\n" );

  return ;
}//end of function: printVectorRowForm( )


} // end of namespace mumech

/*end of file*/