Contains macros and function definitions for common array operations. More...

#include <stdio.h>
#include <stdlib.h>
#include <basic.h>
#include <math.h>

Macros
#define	_ArrayIndexnD_(N, index, imax, i, ghost)

#define	_ArrayIndex1D_(N, imax, i, ghost, index)

#define	_ArrayIndex1D2_(N, imax, i, ghost, index)

#define	_ArrayIndex1D3_(N, imax, i, ghost, index)

#define	_ArrayIndex1DWO_(N, imax, i, offset, ghost, index)

#define	_ArrayIndex1DWO2_(N, imax, i, offset, ghost, index)

#define	_ArrayIndex1DWO3_(N, imax, i, offset, ghost, index)

#define	_ArrayIncrementIndex_(N, imax, i, done)

#define	_ArrayIncrementIndexWithLBound_(N, imax, imin, i, done)

#define	_ArraySetValue_(x, size, value)

#define	_ArraySum1D_(x, a, size)

#define	_ArrayScale1D_(x, a, size)

#define	_ArraySubtract1D_(x, a, b, size)

#define	_ArrayAdd1D_(x, a, b, size)

#define	_ArrayMultiply1D_(x, a, b, size)

#define	_ArrayMultiply3Add1D_(x, a, b, c, d, e, f, size)

#define	_ArrayConvexCombination1D_(z, a, x, y, size)

#define	_ArrayAYPX_(x, a, y, size)

#define	_ArrayAXPY_(x, a, y, size)

#define	_ArrayAXBY_(z, a, x, b, y, size)

#define	_ArrayAXBYCZ_(w, a, x, b, y, c, z, size)

#define	_ArrayScaledAXPY_(x, a, e, y, size)

#define	_ArrayCopy1D_(x, y, size)

#define	_ArrayCopy1D2_(x, y, size)

#define	_ArrayCopy1D3_(x, y, size)

#define	_ArrayScaleCopy1D_(x, a, y, size)

#define	_ArrayAddCopy1D_(x, a, y, size)

#define	_ArrayProduct1D_(x, size, p)

#define	_ArrayBlockMultiply_(x, a, n, bs)

#define	INLINE inline

Functions
INLINE int	ArrayCopynD (int, const double , double , int , int, int, int , int)

INLINE double	ArrayMaxnD (int, int, int , int, int , double *)

INLINE double	ArraySumSquarenD (int, int, int , int, int , double *)

INLINE double	ArraySumAbsnD (int, int, int , int, int , double *)

INLINE void	ArrayCheckEqual (const char , const double , const double *, int, int)

INLINE void	ArrayCheckEqual2 (const char , const double , const double *, int)

INLINE int	ArrayCopynDComponent (int ndims, const double x, double y, int dim, int g1, int g2, int index, int nvars_from, int nvars_to, int var_from, int var_to)

Detailed Description

Contains macros and function definitions for common array operations.

Author: Debojyoti Ghosh

Definition in file arrayfunctions.h.

Macro Definition Documentation

#define _ArrayIndexnD_	(	N,
		index,
		imax,
		i,
		ghost
	)

Value:

{ \
    int arraycounter, term=1, index_copy=index; \
    for (arraycounter=0; arraycounter<N; arraycounter++) term *= (imax[arraycounter]+2*(ghost));\
    for (arraycounter=N-1; arraycounter>=0; arraycounter--) {\
      term /= (imax[arraycounter]+2*(ghost)); \
      i[arraycounter] = index_copy/term; \
      index_copy -= i[arraycounter]*term; \
    } \
    for (arraycounter=0; arraycounter<N; arraycounter++) i[arraycounter] -= (ghost);\
  }

Returns the N -dimensional index i[N] in an N -dimensional array of size imax[N] with ghost number of ghost points, given the 1-dimensional index in the corresponding 1-dimensional array stored in memory.

See Also: _ArrayIndex1D_

Definition at line 21 of file arrayfunctions.h.

#define _ArrayIndex1D_	(	N,
		imax,
		i,
		ghost,
		index
	)

Value:

{ \
    index = i[N-1]+(ghost); \
    int arraycounter; \
    for (arraycounter = (N)-2; arraycounter > -1; arraycounter--) { \
      index = ((index*(imax[arraycounter]+2*(ghost))) + (i[arraycounter]+(ghost))); \
    } \
  }

Returns 1-dimensional index in the corresponding 1-dimensional array stored in memory, given the N -dimensional index i[N] in an N -dimensional array of size imax[N] with ghost number of ghost points.

See Also: _ArrayIndexnD_, _ArrayIndex1D2_, _ArrayIndex1D3_

Definition at line 40 of file arrayfunctions.h.

#define _ArrayIndex1D2_	(	N,
		imax,
		i,
		ghost,
		index
	)

Value:

{ \
    index = i[1]+(ghost); \
    index = ((index*(imax[0]+2*(ghost))) + (i[0]+(ghost))); \
  }

Returns 1-dimensional index in the corresponding 1-dimensional array stored in memory, given the 2-dimensional index i[2] in an 2-dimensional array of size imax[2] with ghost number of ghost points. N is not used, but retained for uniformity.

See Also: _ArrayIndex1D_, _ArrayIndex1D3_

Definition at line 56 of file arrayfunctions.h.

#define _ArrayIndex1D3_	(	N,
		imax,
		i,
		ghost,
		index
	)

Value:

{ \
    index = i[2]+(ghost); \
    index = ((index*(imax[1]+2*(ghost))) + (i[1]+(ghost))); \
    index = ((index*(imax[0]+2*(ghost))) + (i[0]+(ghost))); \
  }

Returns 1-dimensional index in the corresponding 1-dimensional array stored in memory, given the 3-dimensional index i[3] in an 3-dimensional array of size imax[3] with ghost number of ghost points. N is not used, but retained for uniformity.

See Also: _ArrayIndex1D_, _ArrayIndex1D2_

Definition at line 69 of file arrayfunctions.h.

#define _ArrayIndex1DWO_	(	N,
		imax,
		i,
		offset,
		ghost,
		index
	)

Value:

{ \
    index = i[N-1]+(ghost)+ offset[N-1];\
    int arraycounter; \
    for (arraycounter = (N)-2; arraycounter > -1; arraycounter--) { \
      index = ((index*(imax[arraycounter]+2*(ghost))) + (i[arraycounter]+(ghost)+offset[arraycounter]));\
    } \
  }

Returns 1-dimensional index in the corresponding 1-dimensional array stored in memory, given the N -dimensional index i[N] + an offset[N] in an N -dimensional array of size imax[N] with ghost number of ghost points.

See Also: _ArrayIndexnD_, _ArrayIndex1D_, _ArrayIndex1DWO2_, _ArrayIndex1DWO3_

Definition at line 83 of file arrayfunctions.h.

#define _ArrayIndex1DWO2_	(	N,
		imax,
		i,
		offset,
		ghost,
		index
	)

Value:

{ \
    index = i[1]+(ghost)+ offset[1];\
    index = ((index*(imax[0]+2*(ghost))) + (i[0]+(ghost)+offset[0]));\
  }

Returns 1-dimensional index in the corresponding 1-dimensional array stored in memory, given the 2-dimensional index i[2] + an offset[2] in an 2-dimensional array of size imax[2] with ghost number of ghost points. N is not used, but retained for uniformity.

See Also: _ArrayIndex1DWO_, _ArrayIndex1DWO3_

Definition at line 100 of file arrayfunctions.h.

#define _ArrayIndex1DWO3_	(	N,
		imax,
		i,
		offset,
		ghost,
		index
	)

Value:

{ \
    index = i[2]+(ghost)+ offset[2];\
    index = ((index*(imax[1]+2*(ghost))) + (i[1]+(ghost)+offset[1]));\
    index = ((index*(imax[0]+2*(ghost))) + (i[0]+(ghost)+offset[0]));\
  }

Returns 1-dimensional index in the corresponding 1-dimensional array stored in memory, given the 3-dimensional index i[3] + an offset[3] in an 3-dimensional array of size imax[3] with ghost number of ghost points. N is not used, but retained for uniformity.

See Also: _ArrayIndex1DWO_, _ArrayIndex1DWO2_

Definition at line 114 of file arrayfunctions.h.

#define _ArrayIncrementIndex_	(	N,
		imax,
		i,
		done
	)

Value:

{ \
    int arraycounter = 0; \
    while (arraycounter < (N)) { \
      if (i[arraycounter] == imax[arraycounter]-1) { \
        i[arraycounter] = 0; \
        arraycounter++; \
      } else { \
        i[arraycounter]++; \
        break; \
      } \
    } \
    if (arraycounter == (N)) done = 1; \
    else          done = 0; \
  }

Increments an N -dimensional index i[N] by one. If it reaches the provided bounds imax[N], i.e., if i[c] = imax[c]-1 for all c = 0,...,N-1), then done = 1; else done = 0.

Definition at line 126 of file arrayfunctions.h.

#define _ArrayIncrementIndexWithLBound_	(	N,
		imax,
		imin,
		i,
		done
	)

Value:

{ \
    int arraycounter = 0; \
    while (arraycounter < (N)) { \
      if (i[arraycounter] == imax[arraycounter]-1) { \
        i[arraycounter] = imin[arraycounter]; \
        arraycounter++; \
      } else { \
        i[arraycounter]++; \
        break; \
      } \
    } \
    if (arraycounter == (N)) done = 1; \
    else          done = 0; \
  }

Increments an N -dimensional index i[N] by one. If it reaches the provided bounds imax[N], i.e., if i[c] = imax[c]-1 for all c = 0,...,N-1), then done = 1; else done = 0. This is the same as ArrayIncrementIndex but with a specified lower bound imin instead of 0.

Definition at line 149 of file arrayfunctions.h.

#define _ArraySetValue_	(	x,
		size,
		value
	)

Value:

{                                                                                                                 \
    int arraycounter;                                                                                               \
    for (arraycounter = 0; arraycounter < (size); arraycounter++)  x[arraycounter] = (value);                       \
  }

Set all elements of a 1-dimensional array x (any datatype) of length size to a scalar value

Definition at line 169 of file arrayfunctions.h.

#define _ArraySum1D_	(	x,
		a,
		size
	)

Value:

{                                                                                                                 \
    a = 0; \
    int arraycounter;                                                                                               \
    for (arraycounter=0; arraycounter<size; arraycounter++) a += x[arraycounter];                                   \
  }

Compute the sum of all elements of a 1-dimensional array x of length size.

Definition at line 179 of file arrayfunctions.h.

#define _ArrayScale1D_	(	x,
		a,
		size
	)

Value:

{                                                                                                                 \
    int arraycounter;                                                                                               \
    for (arraycounter=0; arraycounter<size; arraycounter++) x[arraycounter] *= a;                                   \
  }

Multiply all elements of a 1-dimensional array x of length size by a scalar value

Definition at line 190 of file arrayfunctions.h.

#define _ArraySubtract1D_	(	x,
		a,
		b,
		size
	)

Value:

{                                                                                                                 \
    int arraycounter;                                                                                               \
    for (arraycounter=0; arraycounter<size; arraycounter++) x[arraycounter] = a[arraycounter] - b[arraycounter];    \
  }

Element-wise subtraction x = a - b, where x, a, and b are 1-dimensional arrays of length size

See Also: _ArrayAdd1D_, _ArrayMultiply1D_

Definition at line 201 of file arrayfunctions.h.

#define _ArrayAdd1D_	(	x,
		a,
		b,
		size
	)

Value:

{                                                                                                                 \
    int arraycounter;                                                                                               \
    for (arraycounter=0; arraycounter<size; arraycounter++) x[arraycounter] = a[arraycounter] + b[arraycounter];    \
  }

Element-wise addition x = a + b, where x, a, and b are 1-dimensional arrays of length size

See Also: _ArraySubtract1D_, _ArrayMultiply1D_

Definition at line 212 of file arrayfunctions.h.

#define _ArrayMultiply1D_	(	x,
		a,
		b,
		size
	)

Value:

{                                                                                                                 \
    int arraycounter;                                                                                               \
    for (arraycounter=0; arraycounter<size; arraycounter++) x[arraycounter] = a[arraycounter] * b[arraycounter];    \
  }

Element-wise multiplication x = a . b, where x, a, and b are 1-dimensional arrays of length size (a.k.a. dot product).

See Also: _ArraySubtract1D_, _ArrayAdd1D_

Definition at line 223 of file arrayfunctions.h.

#define _ArrayMultiply3Add1D_	(	x,
		a,
		b,
		c,
		d,
		e,
		f,
		size
	)

Value:

{                                                                                                                 \
    int arraycounter;                                                                                               \
    for (arraycounter=0; arraycounter<size; arraycounter++) \
      x[arraycounter] = a[arraycounter]*b[arraycounter]+c[arraycounter]*d[arraycounter]+e[arraycounter]*f[arraycounter]; \
  }

Element-wise x =a . b + c . d + e . f, where x, a, b, c, d, e, and f, are 1-dimensional arrays of length size.

See Also: _ArrayMultiply1D_

Definition at line 234 of file arrayfunctions.h.

#define _ArrayConvexCombination1D_	(	z,
		a,
		x,
		y,
		size
	)

Value:

{                                                                                                                 \
    int arraycounter;                                                                                               \
    for (arraycounter=0; arraycounter<size; arraycounter++) \
      z[arraycounter] = a[arraycounter]*x[arraycounter]+(1.0-a[arraycounter])*y[arraycounter]; \
  }

Element-wise convex combination z = a . x + (1-a) . y, where a, x, y, z are 1-dimensional arrays of length size.

Definition at line 245 of file arrayfunctions.h.

#define _ArrayAYPX_	(	x,
		a,
		y,
		size
	)

Value:

{                                                                                                                 \
    int arraycounter;                                                                                               \
    for (arraycounter=0; arraycounter<size; arraycounter++) \
      y[arraycounter] = a*y[arraycounter] + x[arraycounter];\
  }

Element-wise AYPX y = a y + x, where a is a scalar, and x, y, z are 1-dimensional arrays of length size.

See Also: _ArrayAXPY_, _ArrayAXBY_, _ArrayAXBYCZ_, _ArrayScaledAXPY_

Definition at line 258 of file arrayfunctions.h.

#define _ArrayAXPY_	(	x,
		a,
		y,
		size
	)

Value:

{                                                                                                                 \
    int arraycounter;                                                                                               \
    for (arraycounter=0; arraycounter<size; arraycounter++) y[arraycounter] += a*x[arraycounter];                   \
  }

Element-wise AXPY y = a x + y, where a is a scalar, and x, y, z are 1-dimensional arrays of length size.

See Also: _ArrayAYPX_, _ArrayAXBY_, _ArrayAXBYCZ_, _ArrayScaledAXPY_

Definition at line 271 of file arrayfunctions.h.

#define _ArrayAXBY_	(	z,
		a,
		x,
		b,
		y,
		size
	)

Value:

{                                                                                                                 \
    int arraycounter;                                                                                               \
    for (arraycounter=0; arraycounter<size; arraycounter++) z[arraycounter] = a*x[arraycounter]+b*y[arraycounter];  \
  }

Element-wise AXPY z = a x + b y, where a , b are scalars, and x, y, z are 1-dimensional arrays of length size.

See Also: _ArrayAYPX_, _ArrayAXPY_, _ArrayAXBYCZ_, _ArrayScaledAXPY_

Definition at line 283 of file arrayfunctions.h.

#define _ArrayAXBYCZ_	(	w,
		a,
		x,
		b,
		y,
		c,
		z,
		size
	)

Value:

{                                                                                                                 \
    int arraycounter;                                                                                               \
    for (arraycounter=0; arraycounter<size; arraycounter++) w[arraycounter] = a*x[arraycounter]+b*y[arraycounter]+c*z[arraycounter];  \
  }

Element-wise AXPY w = a x + b y + c z, where a, b, c are scalars, and x, y, z, w are 1-dimensional arrays of length size.

See Also: _ArrayAYPX_, _ArrayAXPY_, _ArrayScaledAXPY_

Definition at line 295 of file arrayfunctions.h.

#define _ArrayScaledAXPY_	(	x,
		a,
		e,
		y,
		size
	)

Value:

{                                                                                                                 \
    int arraycounter;                                                                                               \
    for (arraycounter=0; arraycounter<size; arraycounter++) \
      y[arraycounter] = e*(y[arraycounter]+a*x[arraycounter]);                   \
  }

Element-wise Scaled AXPY y = e * (y + a * x), where a, e are scalars, and x, y are 1-dimensional arrays of length size.

See Also: _ArrayAYPX_, _ArrayAXPY_, _ArrayAXBYCZ_

Definition at line 307 of file arrayfunctions.h.

#define _ArrayCopy1D_	(	x,
		y,
		size
	)

Value:

{ \
    int arraycounter; \
    for (arraycounter = 0; arraycounter < size; arraycounter++) y[arraycounter] = x[arraycounter]; \
  }

Element-wise copy y = x, where x, y are 1-dimensional arrays of length size.

See Also: _ArrayCopy1D2_, _ArrayCopy1D3_, _ArrayScaleCopy1D_, _ArrayAddCopy1D_

Definition at line 319 of file arrayfunctions.h.

#define _ArrayCopy1D2_	(	x,
		y,
		size
	)

Value:

{ \
    y[0] = x[0]; \
    y[1] = x[1]; \
  }

Element-wise copy y = x, where x, y are 1-dimensional arrays of length 2. size is not used but retained for uniformity.

See Also: _ArrayCopy1D_, _ArrayCopy1D3_

Definition at line 331 of file arrayfunctions.h.

#define _ArrayCopy1D3_	(	x,
		y,
		size
	)

Value:

{ \
    y[0] = x[0]; \
    y[1] = x[1]; \
    y[2] = x[2]; \
  }

Element-wise copy y = x, where x, y are 1-dimensional arrays of length 3. size is not used but retained for uniformity.

See Also: _ArrayCopy1D_, _ArrayCopy1D2_

Definition at line 343 of file arrayfunctions.h.

#define _ArrayScaleCopy1D_	(	x,
		a,
		y,
		size
	)

Value:

{ \
    int arraycounter; \
    for (arraycounter = 0; arraycounter < size; arraycounter++) y[arraycounter] = a*x[arraycounter]; \
  }

Element-wise scale and copy y = a * x, where is a scalar, and x, y are one-dimensional arrays of length size.

See Also: _ArrayCopy1D_, _ArrayAddCopy1D_

Definition at line 356 of file arrayfunctions.h.

#define _ArrayAddCopy1D_	(	x,
		a,
		y,
		size
	)

Value:

{ \
    int arraycounter; \
    for (arraycounter = 0; arraycounter < size; arraycounter++) y[arraycounter] = a+x[arraycounter]; \
  }

Element-wise add and copy y = a + x, where x,y are one-dimensional arrays of length size, and a is a scalar.

See Also: _ArrayCopy1D_, _ArrayScaleCopy1D_

Definition at line 368 of file arrayfunctions.h.

#define _ArrayProduct1D_	(	x,
		size,
		p
	)

Value:

{ \
    int arraycounter = 0; p = 1; \
    for (arraycounter=0; arraycounter<size; arraycounter++) p *= x[arraycounter]; \
  }

p is the product of all the elements of the one-dimensional array x of length size.

Definition at line 377 of file arrayfunctions.h.

#define _ArrayBlockMultiply_	(	x,
		a,
		n,
		bs
	)

Value:

{ \
    int arraycounter1,arraycounter2; \
    for (arraycounter1=0; arraycounter1<n; arraycounter1++) { \
      for (arraycounter2=0; arraycounter2<bs; arraycounter2++) { \
        x[bs*arraycounter1+arraycounter2] *= a[arraycounter1]; \
      } \
    }\
  }

Given two arrays: x of size n*bs, and a of size n, this macro implements: x[i][j] *= a[i] where i = 1,...,n, j = 1,...,bs, and x is stored as a 1D array in row-major format, i.e., x[i][j] = x[i*bs+j].

Definition at line 388 of file arrayfunctions.h.

#define INLINE inline

Definition at line 399 of file arrayfunctions.h.

Function Documentation

INLINE int ArrayCopynD	(	int	ndims,
		const double *	x,
		double *	y,
		int *	dim,
		int	g1,
		int	g2,
		int *	index,
		int	nvars
	)

Copy one n-D array to another n-D array (both of which are stored in memory as 1D arrays)

Parameters

ndims	number of dimensions
x	copy-from array
y	copy-to array
dim	integer array of size in each dimension
g1	number of ghost points in copy-from array x
g2	number of ghost points in copy-to array y
index	pre-allocated (by the calling function) integer array of size ndims
nvars	number of elements at one array location, can be > 1 for systems of equations)

Definition at line 410 of file arrayfunctions.h.

 {
   if (!y) {
     fprintf(stderr,"Error in ArrayCopynD(): array \"y\" not allocated.\n");
     return(1);
   }
   if (!x) {
     fprintf(stderr,"Error in ArrayCopynD(): array \"x\" not allocated.\n");
     return(1);
   }
   int done = 0;
   _ArraySetValue_(index,ndims,0);
   while (!done) {
     int p1, p2;
     _ArrayIndex1D_(ndims,dim,index,g1,p1);
     _ArrayIndex1D_(ndims,dim,index,g2,p2);
     _ArrayCopy1D_((x+p1*nvars),(y+p2*nvars),nvars);
     _ArrayIncrementIndex_(ndims,dim,index,done);
   }
   return(0);
 }

INLINE double ArrayMaxnD	(	int	nvars,
		int	ndims,
		int *	dim,
		int	ghosts,
		int *	index,
		double *	x
	)

Returns the maximum magnitude element in an n-D array (useful for L_inf norm)

Parameters

nvars	number of elements at one array location, can be > 1 for systems of equations
ndims	number of dimensions
dim	integer array containing the size of x in each dimension
ghosts	number of ghost points in the array x
index	pre-allocated (by the calling function) integer array of size ndims
x	the array

Definition at line 486 of file arrayfunctions.h.

 {
   double sum = 0;
   int done = 0; _ArraySetValue_(index,ndims,0);
   while (!done) {
     int p; _ArrayIndex1D_(ndims,dim,index,ghosts,p);
     int v;
     for (v=0; v<nvars; v++) {
       double term = ( x[p*nvars+v]>0 ? x[p*nvars+v] : -x[p*nvars+v] );
       if (term > sum) sum = term;
     }
     _ArrayIncrementIndex_(ndims,dim,index,done);
   }
   return(sum);
 }

INLINE double ArraySumSquarenD	(	int	nvars,
		int	ndims,
		int *	dim,
		int	ghosts,
		int *	index,
		double *	x
	)

Returns the sum-of-squares of the elements in an n-D array (useful for L_2 norm)

Parameters

nvars	number of elements at one array location, can be > 1 for systems of equations
ndims	number of dimensions
dim	integer array of size in each dimension
ghosts	number of ghost points in the array x
index	pre-allocated (by the calling function) integer array of size ndims
x	the array

Definition at line 529 of file arrayfunctions.h.

 {
   double sum = 0;
   int done = 0; _ArraySetValue_(index,ndims,0);
   while (!done) {
     int p; _ArrayIndex1D_(ndims,dim,index,ghosts,p);
     int v; for (v=0; v<nvars; v++) sum += (x[p*nvars+v]*x[p*nvars+v]);
     _ArrayIncrementIndex_(ndims,dim,index,done);
   }
   return(sum);
 }

INLINE double ArraySumAbsnD	(	int	nvars,
		int	ndims,
		int *	dim,
		int	ghosts,
		int *	index,
		double *	x
	)

Returns the sum-of-magnitudes of the elements in an n-D array (useful for L_1 norm)

Parameters

nvars	number of elements at one array location, can be > 1 for systems of equations
ndims	number of dimensions
dim	integer array of size in each dimension
ghosts	number of ghost points in the array x
index	pre-allocated (by the calling function) integer array of size ndims
x	the array

Definition at line 510 of file arrayfunctions.h.

 {
   double sum = 0;
   int done = 0; _ArraySetValue_(index,ndims,0);
   while (!done) {
     int p; _ArrayIndex1D_(ndims,dim,index,ghosts,p);
     int v; for (v=0; v<nvars; v++) sum += ( x[p*nvars+v]>0 ? x[p*nvars+v] : -x[p*nvars+v] );
     _ArrayIncrementIndex_(ndims,dim,index,done);
   }
   return(sum);
 }

INLINE void ArrayCheckEqual	(	const char *	msg,
		const double *	var_adj,
		const double *	var_sep,
		int	npoints,
		int	nvars
	)

Definition at line 547 of file arrayfunctions.h.

 {
     double max_err = 0.0;
     for (int j=0; j<npoints; j++) {
         for (int v=0; v<nvars; v++) {
             if (var_sep[j+v*npoints] != var_adj[j*nvars+v]) {
                 double diff = fabs(var_sep[j+v*npoints]-var_adj[j*nvars+v]);
                 max_err = (max_err < diff) ? diff : max_err;
             }
         }
     }
 
     if (max_err > 1e-10) {
         printf("ArrayCheckEqual: %-30s max_err = %e\n", msg, max_err);
         exit(0);
     }
     return;
 }

INLINE void ArrayCheckEqual2	(	const char *	msg,
		const double *	var_adj,
		const double *	var_sep,
		int	npoints
	)

Definition at line 566 of file arrayfunctions.h.

 {
     double max_err = 0.0;
     for (int j=0; j<npoints; j++) {
         if (var_sep[j] != var_adj[j]) {
             double diff = fabs(var_sep[j]-var_adj[j]);
             max_err = (max_err < diff) ? diff : max_err;
         }
     }
 
     if (max_err > 1e-10) {
         printf("ArrayCheckEqual: %-30s max_err = %e\n", msg, max_err);
         exit(0);
     }
     return;
 }

INLINE int ArrayCopynDComponent	(	int	ndims,
		const double *	x,
		double *	y,
		int *	dim,
		int	g1,
		int	g2,
		int *	index,
		int	nvars_from,
		int	nvars_to,
		int	var_from,
		int	var_to
	)

Copies a component of an n-D array to another n-D array of at least one component (both of which are stored in memory as 1D arrays); the two arrays must be of the same n-dimensional size (locally and globally)

Parameters

ndims	number of dimensions
x	copy-from array
y	copy-to array
dim	integer array of size in each dimension
g1	number of ghost points in copy-from array x
g2	number of ghost points in copy-to array y
index	pre-allocated (by the calling function) integer array of size ndims
nvars_from	number of components/variables in copy-from array
nvars_to	number of components/variables in copy-from array
var_from	component to copy from in x
var_to	component to copy to in y

Definition at line 444 of file arrayfunctions.h.

 {
   if (!y) {
     fprintf(stderr,"Error in ArrayCopynD(): array \"y\" not allocated.\n");
     return(1);
   }
   if (!x) {
     fprintf(stderr,"Error in ArrayCopynD(): array \"x\" not allocated.\n");
     return(1);
   }
   if ((var_from >= nvars_from) || (var_from < 0)) {
     fprintf(stderr,"Error in ArrayCopynD(): specified component exceeds bounds.\n");
     return(1);
   }
   if ((var_to >= nvars_to) || (var_to < 0)) {
     fprintf(stderr,"Error in ArrayCopynD(): specified component exceeds bounds.\n");
     return(1);
   }
 
   int done = 0;
   _ArraySetValue_(index,ndims,0);
   while (!done) {
     int p1, p2;
     _ArrayIndex1D_(ndims,dim,index,g1,p1); 
     _ArrayIndex1D_(ndims,dim,index,g2,p2);
     (y+p2*nvars_to)[var_to] = (x+p1*nvars_from)[var_from];
     _ArrayIncrementIndex_(ndims,dim,index,done);
   }
   return(0);
 }

Macros

Functions

Detailed Description

Macro Definition Documentation

Function Documentation