From 1f543eb0efb2ef00fea2ac2829b41ec7a9994ede Mon Sep 17 00:00:00 2001 From: yye00 Date: Thu, 26 Aug 2004 10:40:09 +0000 Subject: continuing cleaning ... git-svn-id: http://svn.cactuscode.org/arrangements/CactusBase/LocalReduce/trunk@28 7daa882c-dc44-4453-834e-278d26b18e6a --- src/Reduction.c | 72 +-- src/ReductionAvg.c | 29 +- src/ReductionCount.c | 20 +- src/ReductionMax.c | 31 +- src/ReductionMin.c | 33 +- src/ReductionNorm1.c | 1273 ++++++++++++++++++++++++++++++++++++++++++------ src/ReductionNorm2.c | 1265 +++++++++++++++++++++++++++++++++++++++++------ src/ReductionNorm3.c | 1268 +++++++++++++++++++++++++++++++++++++++++------ src/ReductionNorm4.c | 1266 +++++++++++++++++++++++++++++++++++++++++------ src/ReductionNormInf.c | 1262 +++++++++++++++++++++++++++++++++++++++++------ src/ReductionSum.c | 1246 ++++++++++++++++++++++++++++++++++++++++++----- src/Startup.c | 3 +- src/local_reductions.h | 50 +- src/make.code.defn | 2 +- 14 files changed, 6821 insertions(+), 999 deletions(-) diff --git a/src/Reduction.c b/src/Reduction.c index 91d3bc6..118e74d 100644 --- a/src/Reduction.c +++ b/src/Reduction.c @@ -23,7 +23,7 @@ CCTK_FILEVERSION(CCTDevelopment_LocalReduce_Reduction_c); static int copy_real_to_outtype (int num_elems, CCTK_REAL inarray [/* num_elems */], int outtype, - void *outarray /* [num_elems] */); + void *const outarray /* [num_elems] */); /******************************************************************** @@ -99,71 +99,16 @@ int LocalReduce_Reduce (int N_dims, int operator_handle, const void *const input_arrays[], int M_output_numbers, const CCTK_INT output_number_type_codes[], - void *const output_numbers[], + void * const output_numbers[], reduction_fn_t reduction_fn) { - int i, num_points, retval; - int from[1], to[1], iterator[1], points_per_dim[1]; - int *intypes; - CCTK_REAL *buffer; - - - points_per_dim[0] = 1; - from[0] = 0; - to[0] = input_array_dims[0]; - - /* get the total number of array elements */ - for (i = 1; i < N_dims; i++) - { - to[0] *= input_array_dims[i]; - } - - /* check for zero-sized arrays */ - if (to[0] <= 0) - { - CCTK_WARN (2, "LocalReduce_Reduce: Cannot reduce zero-sized arrays"); - return (-1); - } - - if (M_output_numbers != 1) - { - if (M_output_numbers != to[0]) - { - CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING, - "LocalLocalReduce_Reduce: Don't know how to reduce " - "a %d-dimensional array with %d elements " - "to an output array of %d elements", - N_dims, to[0], M_output_numbers); - return (-2); - } - to[0] = 1; - } - num_points = to[0]; - - /* set the array types to intype */ - /* FIXME: could allow to pass in arrays of different types now !!! */ - intypes = malloc (N_input_arrays * sizeof (int)); - for (i = 0; i < N_input_arrays; i++) - { - intypes[i] = input_array_type_codes[i]; - } - - buffer = malloc (M_output_numbers * sizeof (CCTK_REAL)); - + int retval; /* do the reduction on the input arrays */ - retval = reduction_fn (N_dims, from, to, iterator, points_per_dim, - num_points, 1, N_input_arrays, intypes, input_arrays, - M_output_numbers, buffer); - - if (retval == 0 ) - { - /* type-cast the result to the requested datatype */ -/* retval = copy_real_to_outtype (N_input_arrays * M_output_numbers, - buffer, output_number_type_codes, output_numbers);*/ - } - - free (intypes); - free (buffer); + retval = reduction_fn (N_dims, operator_handle, + param_table_handle, N_input_arrays, + input_array_dims, input_array_type_codes, + input_arrays, M_output_numbers, + output_number_type_codes, output_numbers); return (retval); } @@ -178,6 +123,7 @@ int LocalReduce_Reduce (int N_dims, int operator_handle, @enddesc @calls CCTK_VarTypeSize CCTK_GroupTypeFromVarI + ReductionGA ReductionScalar copy_real_to_outtype diff --git a/src/ReductionAvg.c b/src/ReductionAvg.c index b844bb7..ee1c2bc 100644 --- a/src/ReductionAvg.c +++ b/src/ReductionAvg.c @@ -1,7 +1,7 @@ /*@@ @file ReductionAvg.c - @date Thu Apr 3 11:54:53 1997 - @author Thomas Radke, Paul Walker, Erik Schnetter + @date + @author Tom Goodale, Yaakoub Y El Khamra @desc Defines the reduction operator to get the average of an arbitrary array. @@ -36,8 +36,8 @@ static int ReductionAvg (int N_dims, int operator_handle, /*@@ @routine LocalReduce_Mean - @author Thomas Radke - @date 19 Aug 1999 + @author Tom Goodale, Yaakoub Y El Khamra + @date @desc @enddesc @history @@ -117,8 +117,8 @@ int LocalReduce_Mean (int N_dims, int operator_handle, /*****************************************************************************/ /*@@ @routine ReductionAvg - @date Aug 19 1999 - @author Thomas Radke + @date + @author Tom Goodale, Yaakoub Y El Khamra @desc Returns the average of a distributed array with 'num_points' elements. Global reduction is done element-wise (num_outvals == 1) or on the results of the local reductions. @@ -137,8 +137,6 @@ static int ReductionAvg (int N_dims, int operator_handle, int i, j, k, flag, product, num_points; int ierr; int * iters_per_dim; - void * data_pointer[10]; - void * output_buffer[10]; /* indices to hold the temp indices of size N_dims and iteration indices*/ int * indices; @@ -163,9 +161,6 @@ static int ReductionAvg (int N_dims, int operator_handle, CCTK_INT mask_offset; CCTK_INT mask_time_level; - - - /* set the number of points */ num_points = 0; @@ -247,7 +242,7 @@ static int ReductionAvg (int N_dims, int operator_handle, #undef EXTRA_STEP #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define REDUCTION_INITIAL(num) num = 1.0; +#define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) a = a/b; for (i = 0; i < N_input_arrays; i++) @@ -1230,6 +1225,16 @@ static int ReductionAvg (int N_dims, int operator_handle, #endif } } + + /* free memory */ + free (iters_per_dim); + free (indices); + free (actual_indices); + free (actual_iters_per_dim); + free (input_array_offsets); + free (input_array_strides); + free (input_array_min_subscripts); + free (input_array_max_subscripts); return (0); } diff --git a/src/ReductionCount.c b/src/ReductionCount.c index f94b2b1..91ff58d 100644 --- a/src/ReductionCount.c +++ b/src/ReductionCount.c @@ -1,7 +1,7 @@ /*@@ @file ReductionCount.c - @date Thu Apr 3 11:54:53 1997 - @author Thomas Radke, Paul Walker, Erik Schnetter + @date + @author Tom Goodale, Yaakoub Y El Khamra @desc Defines the reduction operator to get the average of an arbitrary array. @@ -35,9 +35,9 @@ static int ReductionCount (int N_dims, int operator_handle, /*@@ - @routine LocalReduce_Mean - @author Thomas Radke - @date 19 Aug 1999 + @routine LocalReduce_Count + @author Tom Goodale, Yaakoub Y El Khamra + @date @desc @enddesc @history @@ -117,8 +117,8 @@ int LocalReduce_Count (int N_dims, int operator_handle, /*****************************************************************************/ /*@@ @routine ReductionCount - @date Aug 19 1999 - @author Thomas Radke + @date + @author Tom Goodale, Yaakoub Y El Khamra @desc Returns the average of a distributed array with 'num_points' elements. Global reduction is done element-wise (num_outvals == 1) or on the results of the local reductions. @@ -137,8 +137,6 @@ static int ReductionCount (int N_dims, int operator_handle, int i, j, k, flag, product, num_points; int ierr; int * iters_per_dim; - void * data_pointer[10]; - void * output_buffer[10]; /* indices to hold the temp indices of size N_dims and iteration indices*/ int * indices; @@ -247,11 +245,12 @@ static int ReductionCount (int N_dims, int operator_handle, #undef EXTRA_STEP #define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define REDUCTION_INITIAL(num) +#define REDUCTION_INITIAL(Count) #define EXTRA_STEP(a, b) for (i = 0; i < N_input_arrays; i++) { + printf("\n number of points: %d,iter:%d, max iter is:%d", num_points,iter,max_iter); /* Do the type matching */ switch (input_array_type_codes[i]) { @@ -1229,7 +1228,6 @@ static int ReductionCount (int N_dims, int operator_handle, break; #endif } - printf("\n number of points:%d and iter is:%d",num_points,iter); } return (0); diff --git a/src/ReductionMax.c b/src/ReductionMax.c index 62883e6..3137bc3 100644 --- a/src/ReductionMax.c +++ b/src/ReductionMax.c @@ -1,7 +1,7 @@ /*@@ @file ReductionMax.c - @date Thu Apr 3 11:54:53 1997 - @author Thomas Radke, Paul Walker, Erik Schnetter + @date + @author Tom Goodale, Yaakoub Y El Khamra @desc Defines the reduction operator to get the average of an arbitrary array. @@ -35,9 +35,9 @@ static int ReductionMax (int N_dims, int operator_handle, /*@@ - @routine LocalReduce_Mean - @author Thomas Radke - @date 19 Aug 1999 + @routine LocalReduce_Max + @author Tom Goodale, Yaakoub Y El Khamra + @date @desc @enddesc @history @@ -117,8 +117,8 @@ int LocalReduce_Max (int N_dims, int operator_handle, /*****************************************************************************/ /*@@ @routine ReductionMax - @date Aug 19 1999 - @author Thomas Radke + @date + @author Tom Goodale, Yaakoub Y El Khamra @desc Returns the average of a distributed array with 'num_points' elements. Global reduction is done element-wise (num_outvals == 1) or on the results of the local reductions. @@ -246,11 +246,11 @@ static int ReductionMax (int N_dims, int operator_handle, #undef EXTRA_STEP #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define REDUCTION_INITIAL(num) num = 1; +#define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) for (i = 0; i < N_input_arrays; i++) - { printf("\n indices is:%d",sum_indices); + { /* Do the type matching */ switch (input_array_type_codes[i]) { @@ -331,7 +331,6 @@ static int ReductionMax (int N_dims, int operator_handle, ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) break; case CCTK_VARIABLE_INT: - printf("\ndoing an int: index is:%d",sum_indices); ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) break; #ifdef CCTK_INT1 @@ -703,7 +702,6 @@ static int ReductionMax (int N_dims, int operator_handle, break; #endif case CCTK_VARIABLE_REAL: - printf("\ndoing an real: index is:%d",sum_indices); ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) break; #ifdef CCTK_REAL4 @@ -1231,7 +1229,16 @@ static int ReductionMax (int N_dims, int operator_handle, #endif } } - + /* free memory */ + free (iters_per_dim); + free (indices); + free (actual_indices); + free (actual_iters_per_dim); + free (input_array_offsets); + free (input_array_strides); + free (input_array_min_subscripts); + free (input_array_max_subscripts); + return (0); } diff --git a/src/ReductionMin.c b/src/ReductionMin.c index 5ad29ea..c0fd0c0 100644 --- a/src/ReductionMin.c +++ b/src/ReductionMin.c @@ -1,7 +1,7 @@ /*@@ @file ReductionMin.c - @date Thu Apr 3 11:54:53 1997 - @author Thomas Radke, Paul Walker, Erik Schnetter + @date + @author Tom Goodale, Yaakoub Y El Khamra @desc Defines the reduction operator to get the average of an arbitrary array. @@ -35,9 +35,9 @@ static int ReductionMin (int N_dims, int operator_handle, /*@@ - @routine LocalReduce_Mean - @author Thomas Radke - @date 19 Aug 1999 + @routine LocalReduce_Min + @author Yaakoub Y El Khamra + @date @desc @enddesc @history @@ -93,7 +93,7 @@ static int ReductionMin (int N_dims, int operator_handle, @vio in @endvar @@*/ -int LocalReduce_Mean (int N_dims, int operator_handle, +int LocalReduce_Min (int N_dims, int operator_handle, int param_table_handle, int N_input_arrays, const CCTK_INT input_array_dims[], const CCTK_INT input_array_type_codes[], @@ -118,7 +118,7 @@ int LocalReduce_Mean (int N_dims, int operator_handle, /*@@ @routine ReductionMin @date Aug 19 1999 - @author Thomas Radke + @author Tom Goodale, Yaakoub Y El Khamra @desc Returns the average of a distributed array with 'num_points' elements. Global reduction is done element-wise (num_outvals == 1) or on the results of the local reductions. @@ -137,8 +137,6 @@ static int ReductionMin (int N_dims, int operator_handle, int i, j, k, flag, product, num_points; int ierr; int * iters_per_dim; - void * data_pointer[10]; - void * output_buffer[10]; /* indices to hold the temp indices of size N_dims and iteration indices*/ int * indices; @@ -163,9 +161,6 @@ static int ReductionMin (int N_dims, int operator_handle, CCTK_INT mask_offset; CCTK_INT mask_time_level; - - - /* set the number of points */ num_points = 0; @@ -246,9 +241,9 @@ static int ReductionMin (int N_dims, int operator_handle, #undef REDUCTION_INITIAL #undef EXTRA_STEP -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; +#define REDUCTION_OPERATION(Max, scalar) if (Max > scalar) Max = scalar; #define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b); +#define EXTRA_STEP(a, b) for (i = 0; i < N_input_arrays; i++) { @@ -1230,6 +1225,16 @@ static int ReductionMin (int N_dims, int operator_handle, #endif } } + + /* free memory */ + free (iters_per_dim); + free (indices); + free (actual_indices); + free (actual_iters_per_dim); + free (input_array_offsets); + free (input_array_strides); + free (input_array_min_subscripts); + free (input_array_max_subscripts); return (0); } diff --git a/src/ReductionNorm1.c b/src/ReductionNorm1.c index f50edaf..64e353e 100644 --- a/src/ReductionNorm1.c +++ b/src/ReductionNorm1.c @@ -1,11 +1,10 @@ /*@@ @file ReductionNorm1.c - @date Thu Apr 3 11:54:53 1997 - @author Thomas Radke, Paul Walker + @date + @author Tom Goodale, Yaakoub Y El Khamra @desc - Defines the reduction operator to get the norm - of an arbitrary array which is defined as: - norm1 = $\Sigma |a_i| / np$ + Defines the reduction operator to get the average + of an arbitrary array. @enddesc @version $Id$ @@*/ @@ -19,25 +18,26 @@ static const char *rcsid = "$Id$"; CCTK_FILEVERSION(CCTDevelopment_LocalReduce_ReductionNorm1_c); + +/* Define the reduction operations */ + + + /* local function prototypes */ -static int ReductionNorm1 (int num_dims, - const int from[/* dim */], - const int to[/* dim */], - int iterator[/* dim */], - const int points_per_dim[/* dim */], - int num_points, - int have_local_points, - int num_inarrays, - const int intypes[/* num_inarrays */], - const void *const inarrays[/* num_inarrays */], - int num_outvals, - CCTK_REAL outvals[/*num_inarrays*num_outvals*/]); +static int ReductionL1 (int N_dims, int operator_handle, + int param_table_handle, int N_input_arrays, + const CCTK_INT input_array_dims[], + const CCTK_INT input_array_type_codes[], + const void *const input_arrays[], + int M_output_numbers, + const CCTK_INT output_number_type_codes[], + void * const output_numbers[]); /*@@ - @routine LocalLocalReduce_L1 - @author Thomas Radke - @date 19 Aug 1999 + @routine LocalReduce_L1 + @author Tom Goodale, Yaakoub Y El Khamra + @date @desc @enddesc @history @@ -94,187 +94,1156 @@ static int ReductionNorm1 (int num_dims, @endvar @@*/ int LocalReduce_L1 (int N_dims, int operator_handle, - int param_table_handle, int N_input_arrays, - const CCTK_INT input_array_dims[], - const CCTK_INT input_array_type_codes[], - const void *const input_arrays[], - int M_output_numbers, - const CCTK_INT output_number_type_codes[], - void *const output_numbers[]) + int param_table_handle, int N_input_arrays, + const CCTK_INT input_array_dims[], + const CCTK_INT input_array_type_codes[], + const void *const input_arrays[], + int M_output_numbers, + const CCTK_INT output_number_type_codes[], + void * const output_numbers[]) { return (LocalReduce_Reduce (N_dims, operator_handle, - param_table_handle, N_input_arrays, - input_array_dims, input_array_type_codes, - input_arrays, M_output_numbers, - output_number_type_codes, output_numbers, - ReductionNorm1)); + param_table_handle, N_input_arrays, + input_array_dims, input_array_type_codes, + input_arrays, M_output_numbers, + output_number_type_codes, output_numbers, + ReductionL1)); } + /*****************************************************************************/ /* local functions */ /*****************************************************************************/ /*@@ - @routine LocalReductionNorm1 - @date Aug 19 1999 - @author Thomas Radke - @desc Returns the "norm1" of a distributed array with + @routine ReductionL1 + @date + @author Tom Goodale, Yaakoub Y El Khamra + @desc Returns the average of a distributed array with 'num_points' elements. Global reduction is done element-wise (num_outvals == 1) or on the results of the local reductions. - - "norm1" is defined as $\Sigma |a_i| / np$. @enddesc @@*/ -static int ReductionNorm1 (int num_dims, - const int from[/* dim */], - const int to[/* dim */], - int iterator[/* dim */], - const int points_per_dim[/* dim */], - int num_points, - int have_local_points, - int num_inarrays, - const int intypes[/* num_inarrays */], - const void *const inarrays[/* num_inarrays */], - int num_outvals, - CCTK_REAL outvals[/*num_inarrays*num_outvals*/]) +static int ReductionL1 (int N_dims, int operator_handle, + int param_table_handle, int N_input_arrays, + const CCTK_INT input_array_dims[], + const CCTK_INT input_array_type_codes[], + const void *const input_arrays[], + int M_output_numbers, + const CCTK_INT output_number_type_codes[], + void * const output_numbers[]) { - int i, total_outvals; + /* utility variables */ + int i, j, k, flag, product, num_points; + int ierr; + int * iters_per_dim; + + /* indices to hold the temp indices of size N_dims and iteration indices*/ + int * indices; + int * actual_indices; + int * actual_iters_per_dim; + int index = 0; + int max_iter = 0;; + int iter = 0; + int sum_indices = 0; + int max_index = 1; + + /* data pointer offset and strides declared here */ + CCTK_INT * input_array_offsets; + CCTK_INT * input_array_strides; + CCTK_INT * input_array_min_subscripts; + CCTK_INT * input_array_max_subscripts; + + /* excesion variables declared here */ + int mask_on = 1; /* mask is by default off=1 */ + void * mask_array; /* same dimensions/indexing as input arrays */ + CCTK_INT mask_type_code; /* one of the CCTK_VARIABLE_* codes */ + CCTK_INT mask_offset; + CCTK_INT mask_time_level; + + /* set the number of points */ + num_points = 0; + + /* allocate memory for iters_per_dim */ + iters_per_dim = (int *)malloc(N_dims * sizeof(int)); + + /* allocate then initialize the values of the strides and subscripts */ + indices = (int *)malloc (N_dims * sizeof(int)); + actual_indices = (int *)malloc (N_dims * sizeof(int)); + actual_iters_per_dim = (int *)malloc (N_dims * sizeof(int)); + + /* allocate then initialize the values of the strides and subscripts */ + input_array_offsets = (CCTK_INT *)malloc (N_input_arrays * sizeof(CCTK_INT)); + input_array_strides = (CCTK_INT *) malloc (N_dims * sizeof(CCTK_INT)); + input_array_min_subscripts = (CCTK_INT *) malloc (N_dims * sizeof(CCTK_INT)); + input_array_max_subscripts = (CCTK_INT *) malloc (N_dims * sizeof(CCTK_INT)); + + for (i = 0; i #include #include @@ -20,25 +18,26 @@ static const char *rcsid = "$Id$"; CCTK_FILEVERSION(CCTDevelopment_LocalReduce_ReductionNorm2_c); + +/* Define the reduction operations */ + + + /* local function prototypes */ -static int ReductionNorm2 (int num_dims, - const int from[/* dim */], - const int to[/* dim */], - int iterator[/* dim */], - const int points_per_dim[/* dim */], - int num_points, - int have_local_points, - int num_inarrays, - const int intypes[/* num_inarrays */], - const void *const inarrays[/* num_inarrays */], - int num_outvals, - CCTK_REAL outvals[/*num_inarrays*num_outvals*/]); +static int ReductionL2 (int N_dims, int operator_handle, + int param_table_handle, int N_input_arrays, + const CCTK_INT input_array_dims[], + const CCTK_INT input_array_type_codes[], + const void *const input_arrays[], + int M_output_numbers, + const CCTK_INT output_number_type_codes[], + void * const output_numbers[]); /*@@ - @routine LocalLocalReduce_L2 - @author Thomas Radke - @date 19 Aug 1999 + @routine LocalReduce_L2 + @author Tom Goodale, Yaakoub Y El Khamra + @date @desc @enddesc @history @@ -95,20 +94,20 @@ static int ReductionNorm2 (int num_dims, @endvar @@*/ int LocalReduce_L2 (int N_dims, int operator_handle, - int param_table_handle, int N_input_arrays, - const CCTK_INT input_array_dims[], - const CCTK_INT input_array_type_codes[], - const void *const input_arrays[], - int M_output_numbers, - const CCTK_INT output_number_type_codes[], - void *const output_numbers[]) + int param_table_handle, int N_input_arrays, + const CCTK_INT input_array_dims[], + const CCTK_INT input_array_type_codes[], + const void *const input_arrays[], + int M_output_numbers, + const CCTK_INT output_number_type_codes[], + void * const output_numbers[]) { return (LocalReduce_Reduce (N_dims, operator_handle, - param_table_handle, N_input_arrays, - input_array_dims, input_array_type_codes, - input_arrays, M_output_numbers, - output_number_type_codes, output_numbers, - ReductionNorm2)); + param_table_handle, N_input_arrays, + input_array_dims, input_array_type_codes, + input_arrays, M_output_numbers, + output_number_type_codes, output_numbers, + ReductionL2)); } @@ -117,159 +116,1135 @@ int LocalReduce_L2 (int N_dims, int operator_handle, /* local functions */ /*****************************************************************************/ /*@@ - @routine ReductionNorm2 - @date Aug 19 1999 - @author Thomas Radke - @desc Returns the "norm2" of a distributed array with + @routine ReductionL2 + @date + @author Tom Goodale, Yaakoub Y El Khamra + @desc Returns the average of a distributed array with 'num_points' elements. Global reduction is done element-wise (num_outvals == 1) or on the results of the local reductions. - - "norm2" is defined as $\sqrt{\Sigma (a_i * a_i) / np}$. @enddesc @@*/ -static int ReductionNorm2 (int num_dims, - const int from[/* dim */], - const int to[/* dim */], - int iterator[/* dim */], - const int points_per_dim[/* dim */], - int num_points, - int have_local_points, - int num_inarrays, - const int intypes[/* num_inarrays */], - const void *const inarrays[/* num_inarrays */], - int num_outvals, - CCTK_REAL outvals[/*num_inarrays*num_outvals*/]) +static int ReductionL2 (int N_dims, int operator_handle, + int param_table_handle, int N_input_arrays, + const CCTK_INT input_array_dims[], + const CCTK_INT input_array_type_codes[], + const void *const input_arrays[], + int M_output_numbers, + const CCTK_INT output_number_type_codes[], + void * const output_numbers[]) { - int i, total_outvals; + /* utility variables */ + int i, j, k, flag, product, num_points; + int ierr; + int * iters_per_dim; + + /* indices to hold the temp indices of size N_dims and iteration indices*/ + int * indices; + int * actual_indices; + int * actual_iters_per_dim; + int index = 0; + int max_iter = 0;; + int iter = 0; + int sum_indices = 0; + int max_index = 1; + + /* data pointer offset and strides declared here */ + CCTK_INT * input_array_offsets; + CCTK_INT * input_array_strides; + CCTK_INT * input_array_min_subscripts; + CCTK_INT * input_array_max_subscripts; + + /* excesion variables declared here */ + int mask_on = 1; /* mask is by default off=1 */ + void * mask_array; /* same dimensions/indexing as input arrays */ + CCTK_INT mask_type_code; /* one of the CCTK_VARIABLE_* codes */ + CCTK_INT mask_offset; + CCTK_INT mask_time_level; + + /* set the number of points */ + num_points = 0; + + /* allocate memory for iters_per_dim */ + iters_per_dim = (int *)malloc(N_dims * sizeof(int)); + + /* allocate then initialize the values of the strides and subscripts */ + indices = (int *)malloc (N_dims * sizeof(int)); + actual_indices = (int *)malloc (N_dims * sizeof(int)); + actual_iters_per_dim = (int *)malloc (N_dims * sizeof(int)); + + /* allocate then initialize the values of the strides and subscripts */ + input_array_offsets = (CCTK_INT *)malloc (N_input_arrays * sizeof(CCTK_INT)); + input_array_strides = (CCTK_INT *) malloc (N_dims * sizeof(CCTK_INT)); + input_array_min_subscripts = (CCTK_INT *) malloc (N_dims * sizeof(CCTK_INT)); + input_array_max_subscripts = (CCTK_INT *) malloc (N_dims * sizeof(CCTK_INT)); + + for (i = 0; i #include #include @@ -20,25 +18,26 @@ static const char *rcsid = "$Id$"; CCTK_FILEVERSION(CCTDevelopment_LocalReduce_ReductionNorm3_c); + +/* Define the reduction operations */ + + + /* local function prototypes */ -static int ReductionNorm3 (int num_dims, - const int from[/* dim */], - const int to[/* dim */], - int iterator[/* dim */], - const int points_per_dim[/* dim */], - int num_points, - int have_local_points, - int num_inarrays, - const int intypes[/* num_inarrays */], - const void *const inarrays[/* num_inarrays */], - int num_outvals, - CCTK_REAL outvals[/*num_inarrays*num_outvals*/]); +static int ReductionL3 (int N_dims, int operator_handle, + int param_table_handle, int N_input_arrays, + const CCTK_INT input_array_dims[], + const CCTK_INT input_array_type_codes[], + const void *const input_arrays[], + int M_output_numbers, + const CCTK_INT output_number_type_codes[], + void * const output_numbers[]); /*@@ - @routine LocalLocalReduce_L3 - @author Thomas Radke - @date Tue Apr 15 2003 + @routine LocalReduce_L3 + @author Tom Goodale, Yaakoub Y El Khamra + @date @desc @enddesc @history @@ -95,179 +94,1154 @@ static int ReductionNorm3 (int num_dims, @endvar @@*/ int LocalReduce_L3 (int N_dims, int operator_handle, - int param_table_handle, int N_input_arrays, - const CCTK_INT input_array_dims[], - const CCTK_INT input_array_type_codes[], - const void *const input_arrays[], - int M_output_numbers, - const CCTK_INT output_number_type_codes[], - void *const output_numbers[]) + int param_table_handle, int N_input_arrays, + const CCTK_INT input_array_dims[], + const CCTK_INT input_array_type_codes[], + const void *const input_arrays[], + int M_output_numbers, + const CCTK_INT output_number_type_codes[], + void * const output_numbers[]) { return (LocalReduce_Reduce (N_dims, operator_handle, - param_table_handle, N_input_arrays, - input_array_dims, input_array_type_codes, - input_arrays, M_output_numbers, - output_number_type_codes, output_numbers, - ReductionNorm3)); + param_table_handle, N_input_arrays, + input_array_dims, input_array_type_codes, + input_arrays, M_output_numbers, + output_number_type_codes, output_numbers, + ReductionL3)); } + /*****************************************************************************/ /* local functions */ /*****************************************************************************/ /*@@ - @routine ReductionNorm3 - @date Tue Apr 15 2003 - @author Thomas Radke - @desc Returns the "norm3" of a distributed array with + @routine ReductionL3 + @date + @author Tom Goodale, Yaakoub Y El Khamra + @desc Returns the average of a distributed array with 'num_points' elements. Global reduction is done element-wise (num_outvals == 1) or on the results of the local reductions. - - "norm3" is defined as $\sqrt{\Sigma |a_i|^3 / np}$. @enddesc @@*/ -static int ReductionNorm3 (int num_dims, - const int from[/* dim */], - const int to[/* dim */], - int iterator[/* dim */], - const int points_per_dim[/* dim */], - int num_points, - int have_local_points, - int num_inarrays, - const int intypes[/* num_inarrays */], - const void *const inarrays[/* num_inarrays */], - int num_outvals, - CCTK_REAL outvals[/*num_inarrays*num_outvals*/]) +static int ReductionL3 (int N_dims, int operator_handle, + int param_table_handle, int N_input_arrays, + const CCTK_INT input_array_dims[], + const CCTK_INT input_array_type_codes[], + const void *const input_arrays[], + int M_output_numbers, + const CCTK_INT output_number_type_codes[], + void * const output_numbers[]) { - int i, total_outvals; + /* utility variables */ + int i, j, k, flag, product, num_points; + int ierr; + int * iters_per_dim; -/* macros to complete the ITERATE_ARRAY macro */ -#define INITIAL_REDUCTION_VALUE(array) 0 + /* indices to hold the temp indices of size N_dims and iteration indices*/ + int * indices; + int * actual_indices; + int * actual_iters_per_dim; + int index = 0; + int max_iter = 0;; + int iter = 0; + int sum_indices = 0; + int max_index = 1; + /* data pointer offset and strides declared here */ + CCTK_INT * input_array_offsets; + CCTK_INT * input_array_strides; + CCTK_INT * input_array_min_subscripts; + CCTK_INT * input_array_max_subscripts; + + /* excesion variables declared here */ + int mask_on = 1; /* mask is by default off=1 */ + void * mask_array; /* same dimensions/indexing as input arrays */ + CCTK_INT mask_type_code; /* one of the CCTK_VARIABLE_* codes */ + CCTK_INT mask_offset; + CCTK_INT mask_time_level; + + /* set the number of points */ + num_points = 0; + + /* allocate memory for iters_per_dim */ + iters_per_dim = (int *)malloc(N_dims * sizeof(int)); + + /* allocate then initialize the values of the strides and subscripts */ + indices = (int *)malloc (N_dims * sizeof(int)); + actual_indices = (int *)malloc (N_dims * sizeof(int)); + actual_iters_per_dim = (int *)malloc (N_dims * sizeof(int)); + + /* allocate then initialize the values of the strides and subscripts */ + input_array_offsets = (CCTK_INT *)malloc (N_input_arrays * sizeof(CCTK_INT)); + input_array_strides = (CCTK_INT *) malloc (N_dims * sizeof(CCTK_INT)); + input_array_min_subscripts = (CCTK_INT *) malloc (N_dims * sizeof(CCTK_INT)); + input_array_max_subscripts = (CCTK_INT *) malloc (N_dims * sizeof(CCTK_INT)); + + for (i = 0; i #include #include @@ -20,25 +18,26 @@ static const char *rcsid = "$Id$"; CCTK_FILEVERSION(CCTDevelopment_LocalReduce_ReductionNorm4_c); + +/* Define the reduction operations */ + + + /* local function prototypes */ -static int ReductionNorm4 (int num_dims, - const int from[/* dim */], - const int to[/* dim */], - int iterator[/* dim */], - const int points_per_dim[/* dim */], - int num_points, - int have_local_points, - int num_inarrays, - const int intypes[/* num_inarrays */], - const void *const inarrays[/* num_inarrays */], - int num_outvals, - CCTK_REAL outvals[/*num_inarrays*num_outvals*/]); +static int ReductionL4 (int N_dims, int operator_handle, + int param_table_handle, int N_input_arrays, + const CCTK_INT input_array_dims[], + const CCTK_INT input_array_type_codes[], + const void *const input_arrays[], + int M_output_numbers, + const CCTK_INT output_number_type_codes[], + void * const output_numbers[]); /*@@ - @routine LocalLocalReduce_L4 - @author Thomas Radke - @date Tue Apr 15 2003 + @routine LocalReduce_L4 + @author Tom Goodale, Yaakoub Y El Khamra + @date @desc @enddesc @history @@ -95,177 +94,1154 @@ static int ReductionNorm4 (int num_dims, @endvar @@*/ int LocalReduce_L4 (int N_dims, int operator_handle, - int param_table_handle, int N_input_arrays, - const CCTK_INT input_array_dims[], - const CCTK_INT input_array_type_codes[], - const void *const input_arrays[], - int M_output_numbers, - const CCTK_INT output_number_type_codes[], - void *const output_numbers[]) + int param_table_handle, int N_input_arrays, + const CCTK_INT input_array_dims[], + const CCTK_INT input_array_type_codes[], + const void *const input_arrays[], + int M_output_numbers, + const CCTK_INT output_number_type_codes[], + void * const output_numbers[]) { return (LocalReduce_Reduce (N_dims, operator_handle, - param_table_handle, N_input_arrays, - input_array_dims, input_array_type_codes, - input_arrays, M_output_numbers, - output_number_type_codes, output_numbers, - ReductionNorm4)); + param_table_handle, N_input_arrays, + input_array_dims, input_array_type_codes, + input_arrays, M_output_numbers, + output_number_type_codes, output_numbers, + ReductionL4)); } + /*****************************************************************************/ /* local functions */ /*****************************************************************************/ /*@@ - @routine ReductionNorm4 - @date Tue Apr 15 2003 - @author Thomas Radke - @desc Returns the "norm4" of a distributed array with + @routine ReductionL4 + @date + @author Tom Goodale, Yaakoub Y El Khamra + @desc Returns the average of a distributed array with 'num_points' elements. Global reduction is done element-wise (num_outvals == 1) or on the results of the local reductions. - - "norm4" is defined as $\sqrt{\Sigma (a_i^4) / np}$. @enddesc @@*/ -static int ReductionNorm4 (int num_dims, - const int from[/* dim */], - const int to[/* dim */], - int iterator[/* dim */], - const int points_per_dim[/* dim */], - int num_points, - int have_local_points, - int num_inarrays, - const int intypes[/* num_inarrays */], - const void *const inarrays[/* num_inarrays */], - int num_outvals, - CCTK_REAL outvals[/*num_inarrays*num_outvals*/]) +static int ReductionL4 (int N_dims, int operator_handle, + int param_table_handle, int N_input_arrays, + const CCTK_INT input_array_dims[], + const CCTK_INT input_array_type_codes[], + const void *const input_arrays[], + int M_output_numbers, + const CCTK_INT output_number_type_codes[], + void * const output_numbers[]) { - int i, total_outvals; + /* utility variables */ + int i, j, k, flag, product, num_points; + int ierr; + int * iters_per_dim; -/* macros to complete the ITERATE_ARRAY macro */ -#define INITIAL_REDUCTION_VALUE(array) 0 -#define POWER4(x) ((x) * (x) * (x) * (x)) + /* indices to hold the temp indices of size N_dims and iteration indices*/ + int * indices; + int * actual_indices; + int * actual_iters_per_dim; + int index = 0; + int max_iter = 0;; + int iter = 0; + int sum_indices = 0; + int max_index = 1; + + /* data pointer offset and strides declared here */ + CCTK_INT * input_array_offsets; + CCTK_INT * input_array_strides; + CCTK_INT * input_array_min_subscripts; + CCTK_INT * input_array_max_subscripts; + + /* excesion variables declared here */ + int mask_on = 1; /* mask is by default off=1 */ + void * mask_array; /* same dimensions/indexing as input arrays */ + CCTK_INT mask_type_code; /* one of the CCTK_VARIABLE_* codes */ + CCTK_INT mask_offset; + CCTK_INT mask_time_level; + + /* set the number of points */ + num_points = 0; + + /* allocate memory for iters_per_dim */ + iters_per_dim = (int *)malloc(N_dims * sizeof(int)); + + /* allocate then initialize the values of the strides and subscripts */ + indices = (int *)malloc (N_dims * sizeof(int)); + actual_indices = (int *)malloc (N_dims * sizeof(int)); + actual_iters_per_dim = (int *)malloc (N_dims * sizeof(int)); + + /* allocate then initialize the values of the strides and subscripts */ + input_array_offsets = (CCTK_INT *)malloc (N_input_arrays * sizeof(CCTK_INT)); + input_array_strides = (CCTK_INT *) malloc (N_dims * sizeof(CCTK_INT)); + input_array_min_subscripts = (CCTK_INT *) malloc (N_dims * sizeof(CCTK_INT)); + input_array_max_subscripts = (CCTK_INT *) malloc (N_dims * sizeof(CCTK_INT)); + for (i = 0; i #include -#include #include "local_reductions.h" -static const char *rcsid = "$Header$"; +static const char *rcsid = "$Id$"; CCTK_FILEVERSION(CCTDevelopment_LocalReduce_ReductionNormInf_c); + +/* Define the reduction operations */ + + + /* local function prototypes */ -static int ReductionNormInf (int num_dims, - const int from[/* dim */], - const int to[/* dim */], - int iterator[/* dim */], - const int points_per_dim[/* dim */], - int num_points, - int have_local_points, - int num_inarrays, - const int intypes[/* num_inarrays */], - const void *const inarrays[/* num_inarrays */], - int num_outvals, - CCTK_REAL outvals[/*num_inarrays*num_outvals*/]); +static int ReductionLInf (int N_dims, int operator_handle, + int param_table_handle, int N_input_arrays, + const CCTK_INT input_array_dims[], + const CCTK_INT input_array_type_codes[], + const void *const input_arrays[], + int M_output_numbers, + const CCTK_INT output_number_type_codes[], + void * const output_numbers[]); /*@@ - @routine LocalLocalReduce_LInf - @author Thomas Radke - @date 19 Aug 1999 + @routine LocalReduce_LInf + @author Tom Goodale, Yaakoub Y El Khamra + @date @desc @enddesc @history @@ -101,48 +100,147 @@ int LocalReduce_LInf (int N_dims, int operator_handle, const void *const input_arrays[], int M_output_numbers, const CCTK_INT output_number_type_codes[], - void *const output_numbers[]) + void * const output_numbers[]) { return (LocalReduce_Reduce (N_dims, operator_handle, - param_table_handle, N_input_arrays, - input_array_dims, input_array_type_codes, - input_arrays, M_output_numbers, - output_number_type_codes, output_numbers, - ReductionNormInf)); + param_table_handle, N_input_arrays, + input_array_dims, input_array_type_codes, + input_arrays, M_output_numbers, + output_number_type_codes, output_numbers, + ReductionLInf)); } + /*****************************************************************************/ /* local functions */ /*****************************************************************************/ /*@@ - @routine ReductionNormInf - @date Aug 19 1999 - @author Thomas Radke - @desc Returns the "norm_inf" of a distributed array with + @routine ReductionLInf + @date + @author Tom Goodale, Yaakoub Y El Khamra + @desc Returns the average of a distributed array with 'num_points' elements. Global reduction is done element-wise (num_outvals == 1) or on the results of the local reductions. - - "norm_inf" is defined as $\max |a_i|$. @enddesc @@*/ -static int ReductionNormInf (int num_dims, - const int from[/* dim */], - const int to[/* dim */], - int iterator[/* dim */], - const int points_per_dim[/* dim */], - int num_points, - int have_local_points, - int num_inarrays, - const int intypes[/* num_inarrays */], - const void *const inarrays[/* num_inarrays */], - int num_outvals, - CCTK_REAL outvals[/*num_inarrays*num_outvals*/]) +static int ReductionLInf (int N_dims, int operator_handle, + int param_table_handle, int N_input_arrays, + const CCTK_INT input_array_dims[], + const CCTK_INT input_array_type_codes[], + const void *const input_arrays[], + int M_output_numbers, + const CCTK_INT output_number_type_codes[], + void * const output_numbers[]) { - int i, total_outvals; + /* utility variables */ + int i, j, k, flag, product, num_points; + int ierr; + int * iters_per_dim; + + /* indices to hold the temp indices of size N_dims and iteration indices*/ + int * indices; + int * actual_indices; + int * actual_iters_per_dim; + int index = 0; + int max_iter = 0;; + int iter = 0; + int sum_indices = 0; + int max_index = 1; + + /* data pointer offset and strides declared here */ + CCTK_INT * input_array_offsets; + CCTK_INT * input_array_strides; + CCTK_INT * input_array_min_subscripts; + CCTK_INT * input_array_max_subscripts; + + /* excesion variables declared here */ + int mask_on = 1; /* mask is by default off=1 */ + void * mask_array; /* same dimensions/indexing as input arrays */ + CCTK_INT mask_type_code; /* one of the CCTK_VARIABLE_* codes */ + CCTK_INT mask_offset; + CCTK_INT mask_time_level; + + /* set the number of points */ + num_points = 0; + + /* allocate memory for iters_per_dim */ + iters_per_dim = (int *)malloc(N_dims * sizeof(int)); + + /* allocate then initialize the values of the strides and subscripts */ + indices = (int *)malloc (N_dims * sizeof(int)); + actual_indices = (int *)malloc (N_dims * sizeof(int)); + actual_iters_per_dim = (int *)malloc (N_dims * sizeof(int)); + + /* allocate then initialize the values of the strides and subscripts */ + input_array_offsets = (CCTK_INT *)malloc (N_input_arrays * sizeof(CCTK_INT)); + input_array_strides = (CCTK_INT *) malloc (N_dims * sizeof(CCTK_INT)); + input_array_min_subscripts = (CCTK_INT *) malloc (N_dims * sizeof(CCTK_INT)); + input_array_max_subscripts = (CCTK_INT *) malloc (N_dims * sizeof(CCTK_INT)); + + for (i = 0; i= (y) ? (x) : (y)) +#define REDUCTION_OPERATION(norm_inf, scalar) norm_inf = MAX(norm_inf, ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) - /* avoid compiler warnings about unused parameters */ - (void) (num_points + 0); - - for (i = total_outvals = 0; i < num_inarrays; i++) - { - switch (intypes[i]) + for (i = 0; i < N_input_arrays; i++) + { + /* Do the type matching */ + switch (input_array_type_codes[i]) { + /* in values type switches*/ case CCTK_VARIABLE_CHAR: -#define REDUCTION_OPERATION(norm_inf, scalar) norm_inf = MAX(norm_inf,scalar) - ITERATE_ARRAY (CCTK_BYTE, num_dims, inarrays[i], - from, to, iterator, points_per_dim, - CCTK_BYTE, outvals, num_outvals, total_outvals); + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_CHAR: + ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) break; - + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL6 + case CCTK_VARIABLE_REAL6: + ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL6, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_COMPLEX: +/* ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product)*/ + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: + ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: + ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: + ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + } + break; case CCTK_VARIABLE_INT: -#undef REDUCTION_OPERATION -#define REDUCTION_OPERATION(norm_inf, scalar) norm_inf = MAX(norm_inf, ABS(scalar)) - ITERATE_ARRAY (CCTK_INT, num_dims, inarrays[i], - from, to, iterator, points_per_dim, - CCTK_INT, outvals, num_outvals, total_outvals); + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_CHAR: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) break; - -#ifdef CCTK_INT1 + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL6 + case CCTK_VARIABLE_REAL6: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL6, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_COMPLEX: +/* ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product)*/ + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + } + break; + #ifdef CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ARRAY (CCTK_INT1, num_dims, inarrays[i], - from, to, iterator, points_per_dim, - CCTK_INT1, outvals, num_outvals, total_outvals); + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_CHAR: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) break; -#endif - -#ifdef CCTK_INT2 + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL6 + case CCTK_VARIABLE_REAL6: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL6, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_COMPLEX: +/* ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product)*/ + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + } + break; + #endif + #ifdef CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ARRAY (CCTK_INT2, num_dims, inarrays[i], - from, to, iterator, points_per_dim, - CCTK_INT2, outvals, num_outvals, total_outvals); + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_CHAR: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) break; -#endif - -#ifdef CCTK_INT4 + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL6 + case CCTK_VARIABLE_REAL6: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL6, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_COMPLEX: +/* ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product)*/ + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + } + break; + #endif + #ifdef CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ARRAY (CCTK_INT4, num_dims, inarrays[i], - from, to, iterator, points_per_dim, - CCTK_INT4, outvals, num_outvals, total_outvals); + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_CHAR: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) break; -#endif - -#ifdef CCTK_INT8 + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL6 + case CCTK_VARIABLE_REAL6: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL6, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_COMPLEX: +/* ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product)*/ + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + } + break; + #endif + #ifdef CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ARRAY (CCTK_INT8, num_dims, inarrays[i], - from, to, iterator, points_per_dim, - CCTK_INT8, outvals, num_outvals, total_outvals); + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_CHAR: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) break; -#endif - + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL6 + case CCTK_VARIABLE_REAL6: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL6, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_COMPLEX: +/* ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product)*/ + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + } + break; + #endif case CCTK_VARIABLE_REAL: - ITERATE_ARRAY (CCTK_REAL, num_dims, inarrays[i], - from, to, iterator, points_per_dim, - CCTK_REAL, outvals, num_outvals, total_outvals); + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_CHAR: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) break; - -#ifdef CCTK_REAL4 + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL6 + case CCTK_VARIABLE_REAL6: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL6, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_COMPLEX: +/* ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product)*/ + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + } + break; + #ifdef CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ARRAY (CCTK_REAL4, num_dims, inarrays[i], - from, to, iterator, points_per_dim, - CCTK_REAL4, outvals, num_outvals, total_outvals); + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_CHAR: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) break; -#endif - -#ifdef CCTK_REAL8 + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL6 + case CCTK_VARIABLE_REAL6: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL6, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_COMPLEX: +/* ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product)*/ + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + } + break; + #endif + #ifdef CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ARRAY (CCTK_REAL8, num_dims, inarrays[i], - from, to, iterator, points_per_dim, - CCTK_REAL8, outvals, num_outvals, total_outvals); + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_CHAR: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) break; -#endif - -#ifdef CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ARRAY (CCTK_REAL16, num_dims, inarrays[i], - from, to, iterator, points_per_dim, - CCTK_REAL16, outvals, num_outvals, total_outvals); + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) break; -#endif - + #ifdef CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL6 + case CCTK_VARIABLE_REAL6: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL6, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_COMPLEX: +/* ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product)*/ + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + } + break; + #endif + #ifdef CCTK_REAL6 + case CCTK_VARIABLE_REAL6: + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_CHAR: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL6 + case CCTK_VARIABLE_REAL6: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL6, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_COMPLEX: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + } + break; + #endif case CCTK_VARIABLE_COMPLEX: #undef REDUCTION_OPERATION -#define REDUCTION_OPERATION(norm_inf, scalar) norm_inf = MAX(norm_inf, CCTK_CmplxAbs(scalar)) - ITERATE_ARRAY (CCTK_COMPLEX, num_dims, inarrays[i], - from, to, iterator, points_per_dim, - CCTK_REAL, outvals, num_outvals, total_outvals); +#define REDUCTION_OPERATION(NormInf, scalar) NormInf += POWER4 ((scalar).Re) + \ + POWER4 ((scalar).Im) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_CHAR: +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product)*/ break; - -#ifdef CCTK_REAL4 -#undef REDUCTION_OPERATION -#define REDUCTION_OPERATION(norm_inf, scalar) norm_inf = MAX(norm_inf, CCTK_Cmplx8Abs(scalar)) - ITERATE_ARRAY (CCTK_COMPLEX8, num_dims, inarrays[i], - from, to, iterator, points_per_dim, - CCTK_REAL4, outvals, num_outvals, total_outvals); + case CCTK_VARIABLE_INT: +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product)*/ break; -#endif - -#ifdef CCTK_REAL8 -#undef REDUCTION_OPERATION -#define REDUCTION_OPERATION(norm_inf, scalar) norm_inf = MAX(norm_inf, CCTK_Cmplx16Abs(scalar)) - ITERATE_ARRAY (CCTK_COMPLEX16, num_dims, inarrays[i], - from, to, iterator, points_per_dim, - CCTK_REAL8, outvals, num_outvals, total_outvals); + #ifdef CCTK_INT1 + case CCTK_VARIABLE_INT1: +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product)*/ + break; + #endif + #ifdef CCTK_INT2 + case CCTK_VARIABLE_INT2: +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product)*/ break; -#endif - -#ifdef CCTK_REAL16 -#undef REDUCTION_OPERATION -#define REDUCTION_OPERATION(norm_inf, scalar) norm_inf = MAX(norm_inf, CCTK_Cmplx32Abs(scalar)) - ITERATE_ARRAY (CCTK_COMPLEX32, num_dims, inarrays[i], - from, to, iterator, points_per_dim, - CCTK_REAL16, outvals, num_outvals, total_outvals); + #endif + #ifdef CCTK_INT4 + case CCTK_VARIABLE_INT4: +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product)*/ break; -#endif - - default: - CCTK_WARN (1, "LocalReductionNormInf: Unknown variable type"); - return (-1); + #endif + #ifdef CCTK_INT8 + case CCTK_VARIABLE_INT8: +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product)*/ + break; + #endif + case CCTK_VARIABLE_REAL: +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product)*/ + break; + #ifdef CCTK_REAL4 + case CCTK_VARIABLE_REAL4: +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product)*/ + break; + #endif + #ifdef CCTK_REAL8 + case CCTK_VARIABLE_REAL8: +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product)*/ + break; + #endif + #ifdef CCTK_REAL6 + case CCTK_VARIABLE_REAL6: +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL6, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product)*/ + break; + #endif + case CCTK_VARIABLE_COMPLEX: +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product)*/ + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + } + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_CHAR: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL6 + case CCTK_VARIABLE_REAL6: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL6, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_COMPLEX: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + } + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_CHAR: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL6 + case CCTK_VARIABLE_REAL6: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL6, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_COMPLEX: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + } + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_CHAR: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_REAL6 + case CCTK_VARIABLE_REAL6: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL6, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + case CCTK_VARIABLE_COMPLEX: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,product) + break; + #endif + } + break; + #endif } } + /* free memory */ + free (iters_per_dim); + free (indices); + free (actual_indices); + free (actual_iters_per_dim); + free (input_array_offsets); + free (input_array_strides); + free (input_array_min_subscripts); + free (input_array_max_subscripts); + return (0); } + + diff --git a/src/ReductionSum.c b/src/ReductionSum.c index 8e0002a..d3e7b8d 100644 --- a/src/ReductionSum.c +++ b/src/ReductionSum.c @@ -1,9 +1,9 @@ /*@@ @file ReductionSum.c - @date Thu Apr 3 11:54:53 1997 - @author Thomas Radke, Paul Walker + @date + @author Tom Goodale, Yaakoub Y El Khamra @desc - Defines the reduction operator to get the sum + Defines the reduction operator to get the average of an arbitrary array. @enddesc @version $Id$ @@ -13,33 +13,32 @@ #include #include "local_reductions.h" -#include "util_Table.h" static const char *rcsid = "$Id$"; CCTK_FILEVERSION(CCTDevelopment_LocalReduce_ReductionSum_c); + +/* Define the reduction operations */ + + + /* local function prototypes */ -static int ReductionSum (int num_dims, - const int from[/* dim */], - const int to[/* dim */], - int iterator[/* dim */], - const int points_per_dim[/* dim */], - int num_points, - int have_local_points, - int num_inarrays, - const int intypes[/* num_inarrays */], - const void *const inarrays[/* num_inarrays */], - int num_outvals, - CCTK_REAL outvals[/*num_inarrays*num_outvals*/]); +static int ReductionSum (int N_dims, int operator_handle, + int param_table_handle, int N_input_arrays, + const CCTK_INT input_array_dims[], + const CCTK_INT input_array_type_codes[], + const void *const input_arrays[], + int M_output_numbers, + const CCTK_INT output_number_type_codes[], + void * const output_numbers[]); /*@@ - @routine LocalReduce_Sum - @author Thomas Radke, Yaakoub El Khamra + @routine LocalReduce_Mean + @author Tom Goodale, Yaakoub Y El Khamra @date @desc - This is the sum reduction routine using the new api @enddesc @history @endhistory @@ -58,7 +57,7 @@ static int ReductionSum (int num_dims, @vtype int @vio in @endvar - @var N_inarrays + @var N_input_arrays @vdesc number of input arrays @vtype int @vio in @@ -73,7 +72,7 @@ static int ReductionSum (int num_dims, @vtype const CCTK_INT @vio in @endvar - @var inarrays + @var input_arrays @vdesc array of pointers to input arrays @vtype const void *const @vio in @@ -95,148 +94,1149 @@ static int ReductionSum (int num_dims, @endvar @@*/ int LocalReduce_Sum (int N_dims, int operator_handle, - int param_table_handle, int N_inarrays, - const CCTK_INT input_array_dims[], - const CCTK_INT input_array_type_codes[], - const void *const inarrays[], - int M_output_numbers, - const CCTK_INT output_number_type_codes[], - void *const output_numbers[]) + int param_table_handle, int N_input_arrays, + const CCTK_INT input_array_dims[], + const CCTK_INT input_array_type_codes[], + const void *const input_arrays[], + int M_output_numbers, + const CCTK_INT output_number_type_codes[], + void * const output_numbers[]) { return (LocalReduce_Reduce (N_dims, operator_handle, - param_table_handle, N_inarrays, - input_array_dims, input_array_type_codes, - inarrays, M_output_numbers, - output_number_type_codes, output_numbers, - ReductionSum)); + param_table_handle, N_input_arrays, + input_array_dims, input_array_type_codes, + input_arrays, M_output_numbers, + output_number_type_codes, output_numbers, + ReductionSum)); } + /*****************************************************************************/ /* local functions */ /*****************************************************************************/ /*@@ @routine ReductionSum @date - @author Thomas Radke, Yaakoub El Khamra - @desc Returns the sum of a distributed array with + @author Tom Goodale, Yaakoub Y El Khamra + @desc Returns the average of a distributed array with 'num_points' elements. Global reduction is done element-wise (num_outvals == 1) or on the results of the local reductions. @enddesc @@*/ -static int ReductionSum (int num_dims, - const int from[/* dim */], - const int to[/* dim */], - int iterator[/* dim */], - const int points_per_dim[/* dim */], - int num_points, - int have_local_points, - int num_inarrays, - const int intypes[/* num_inarrays */], - const void *const inarrays[/* num_inarrays */], - int num_outvals, - CCTK_REAL outvals[/*num_inarrays*num_outvals*/]) +static int ReductionSum (int N_dims, int operator_handle, + int param_table_handle, int N_input_arrays, + const CCTK_INT input_array_dims[], + const CCTK_INT input_array_type_codes[], + const void *const input_arrays[], + int M_output_numbers, + const CCTK_INT output_number_type_codes[], + void * const output_numbers[]) { - int i, total_outvals; - const char *vtypename; + /* utility variables */ + int i, j, k, flag, product, num_points; + int ierr; + int * iters_per_dim; + + /* indices to hold the temp indices of size N_dims and iteration indices*/ + int * indices; + int * actual_indices; + int * actual_iters_per_dim; + int index = 0; + int max_iter = 0;; + int iter = 0; + int sum_indices = 0; + int max_index = 1; + + /* data pointer offset and strides declared here */ + CCTK_INT * input_array_offsets; + CCTK_INT * input_array_strides; + CCTK_INT * input_array_min_subscripts; + CCTK_INT * input_array_max_subscripts; + + /* excesion variables declared here */ + int mask_on = 1; /* mask is by default off=1 */ + void * mask_array; /* same dimensions/indexing as input arrays */ + CCTK_INT mask_type_code; /* one of the CCTK_VARIABLE_* codes */ + CCTK_INT mask_offset; + CCTK_INT mask_time_level; + + /* set the number of points */ + num_points = 0; + + /* allocate memory for iters_per_dim */ + iters_per_dim = (int *)malloc(N_dims * sizeof(int)); + + /* allocate then initialize the values of the strides and subscripts */ + indices = (int *)malloc (N_dims * sizeof(int)); + actual_indices = (int *)malloc (N_dims * sizeof(int)); + actual_iters_per_dim = (int *)malloc (N_dims * sizeof(int)); + + /* allocate then initialize the values of the strides and subscripts */ + input_array_offsets = (CCTK_INT *)malloc (N_input_arrays * sizeof(CCTK_INT)); + input_array_strides = (CCTK_INT *) malloc (N_dims * sizeof(CCTK_INT)); + input_array_min_subscripts = (CCTK_INT *) malloc (N_dims * sizeof(CCTK_INT)); + input_array_max_subscripts = (CCTK_INT *) malloc (N_dims * sizeof(CCTK_INT)); + + for (i = 0; i= max_iter) \ { \ CCTK_WARN(1,"offsets and strides access unallocated memory"); \ return -1; \ } \ + inval = (out_type) typed_vdata[sum_indices]; \ + REDUCTION_OPERATION(*outval,inval); \ num_points++; \ + iter++; \ flag = 0; \ for (k=0;k0;k--) \ { \ product = 1; \ @@ -141,11 +142,12 @@ extern "C" { { \ if ( input_array_offset == 0) \ { \ - iter = 0; \ - sum_indices = 0; \ while (iter < max_iter) \ { \ + inval = (out_type) typed_vdata[sum_indices]; \ + REDUCTION_OPERATION(*outval,inval); \ num_points++; \ + iter++; \ flag = 0; \ for (k=0;k0;k--) \ { \ product = 1; \ @@ -250,6 +249,7 @@ extern "C" { { \ CCTK_WARN(1, "mask_on is not set to a valid value"); \ } \ + EXTRA_STEP(*outval, (out_type)num_points) \ } @@ -263,10 +263,6 @@ int LocalReduce_L3 (REDUCTION_LOCAL_ARRAY_OPERATOR_REGISTER_ARGLIST); int LocalReduce_L4 (REDUCTION_LOCAL_ARRAY_OPERATOR_REGISTER_ARGLIST); int LocalReduce_LInf (REDUCTION_LOCAL_ARRAY_OPERATOR_REGISTER_ARGLIST); int LocalReduce_Sum (REDUCTION_LOCAL_ARRAY_OPERATOR_REGISTER_ARGLIST); -int LocalReduce_CmplxMax1 (REDUCTION_LOCAL_ARRAY_OPERATOR_REGISTER_ARGLIST); -int LocalReduce_CmplxMax2 (REDUCTION_LOCAL_ARRAY_OPERATOR_REGISTER_ARGLIST); -int LocalReduce_CmplxMin1 (REDUCTION_LOCAL_ARRAY_OPERATOR_REGISTER_ARGLIST); -int LocalReduce_CmplxMin2 (REDUCTION_LOCAL_ARRAY_OPERATOR_REGISTER_ARGLIST); typedef int (*reduction_fn_t) (int N_dims, int operator_handle, int param_table_handle, int N_input_arrays, diff --git a/src/make.code.defn b/src/make.code.defn index 591b0b3..04bbb2f 100644 --- a/src/make.code.defn +++ b/src/make.code.defn @@ -2,7 +2,7 @@ # $Header$ # Source files in this directory -SRCS = Reduction.c ReductionAvg.c ReductionCount.c ReductionMax.c ReductionMin.c ReductionNorm1.c ReductionNorm2.c ReductionNorm3.c ReductionNorm4.c ReductionNormInf.c ReductionSum.c Startup.c +SRCS = Startup.c Reduction.c ReductionAvg.c ReductionCount.c ReductionMax.c ReductionMin.c ReductionNorm1.c ReductionNorm2.c ReductionNorm3.c ReductionNorm4.c ReductionNormInf.c ReductionSum.c Startup.c # Subdirectories containing source files SUBDIRS = -- cgit v1.2.3