From 0580b166b649e4f697247b90fb2b92ae7e291610 Mon Sep 17 00:00:00 2001 From: yye00 Date: Tue, 26 Oct 2004 23:36:09 +0000 Subject: new implementation of LocalReduction that does not cause compilers to crash, changed the cascaded switch statements to function calls git-svn-id: http://svn.cactuscode.org/arrangements/CactusBase/LocalReduce/trunk@48 7daa882c-dc44-4453-834e-278d26b18e6a --- src/NormInfFunctions.c | 3963 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 3963 insertions(+) create mode 100644 src/NormInfFunctions.c (limited to 'src/NormInfFunctions.c') diff --git a/src/NormInfFunctions.c b/src/NormInfFunctions.c new file mode 100644 index 0000000..f690619 --- /dev/null +++ b/src/NormInfFunctions.c @@ -0,0 +1,3963 @@ + /*@@ + @file NormInfFunctions.c + @date + @author Tom Goodale, Yaakoub Y El Khamra + @desc + The functions responsible for performing the actual iteration. + Having cascaded switch statements broke some compilers. + @enddesc + @version $Id$ + @@*/ + +#include "cctk.h" +#include "local_reductions.h" +#include "NormInf_Functions.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +int LocalReduce_NormInf_CHAR(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts, int num_points, int * actual_iters_per_dim, int * iters_per_dim, int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; + +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + 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_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, 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: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif + +#define REDUCTION_OPERATION(NormInf, scalar) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + break; + #endif + } + return num_points; +} + +int LocalReduce_NormInf_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts, int num_points, int * actual_iters_per_dim, int * iters_per_dim, int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; + +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + 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; + 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_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, 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: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + break; + #endif + } + return num_points; +} + +#ifdef CCTK_INT1 +int LocalReduce_NormInf_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts, int num_points, int * actual_iters_per_dim, int * iters_per_dim, int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; + +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + 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; + 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_INT11 + 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_INT12 + 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_INT14 + 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_INT18 + 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_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, 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: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + break; + #endif + } + return num_points; +} +#endif + +#ifdef CCTK_INT2 +int LocalReduce_NormInf_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts, int num_points, int * actual_iters_per_dim, int * iters_per_dim, int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; + +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + 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; + 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_INT21 + 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_INT22 + 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_INT24 + 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_INT28 + 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_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, 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: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + break; + #endif + } + return num_points; +} +#endif + +#ifdef CCTK_INT4 +int LocalReduce_NormInf_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts, int num_points, int * actual_iters_per_dim, int * iters_per_dim, int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; + +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + 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; + 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_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, 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: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + break; + #endif + } + return num_points; +} +#endif + +#ifdef CCTK_INT8 +int LocalReduce_NormInf_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts, int num_points, int * actual_iters_per_dim, int * iters_per_dim, int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; + +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + 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; + 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_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, 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: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + break; + #endif + } + return num_points; +} +#endif + +int LocalReduce_NormInf_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts, int num_points, int * actual_iters_per_dim, int * iters_per_dim, int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; + +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + 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; + 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_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, 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: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + break; + #endif + } + return num_points; +} + +#ifdef CCTK_REAL4 +int LocalReduce_NormInf_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts, int num_points, int * actual_iters_per_dim, int * iters_per_dim, int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; + +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + 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; + 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_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, 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: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + break; + #endif + } + return num_points; +} +#endif + +#ifdef CCTK_REAL8 +int LocalReduce_NormInf_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts, int num_points, int * actual_iters_per_dim, int * iters_per_dim, int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; + +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + 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; + 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; + #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_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, 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: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; + +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + break; + #endif + } + return num_points; +} +#endif + +#ifdef CCTK_REAL16 +int LocalReduce_NormInf_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts, int num_points, int * actual_iters_per_dim, int * iters_per_dim, int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; + +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + 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_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, 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: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL4) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL8) typed_vdata[sum_indices]; +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; +#endif +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + break; + #endif + } + return num_points; +} +#endif + +int LocalReduce_NormInf_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts, int num_points, int * actual_iters_per_dim, int * iters_per_dim, int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; + +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL8) (CCTK_Cmplx16Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); +#endif + +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = NormInf + scalar; +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + 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; + 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; + #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_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 + #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_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, 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: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im; + +#define REDUCTION_OPERATION(NormInf, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL8) (CCTK_Cmplx16Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); +#endif + +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = NormInf + scalar; +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im; + +#define REDUCTION_OPERATION(NormInf, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL8) (CCTK_Cmplx16Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); +#endif + +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = NormInf + scalar; +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im; + +#define REDUCTION_OPERATION(NormInf, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL8) (CCTK_Cmplx16Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); +#endif + +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = NormInf + scalar; +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im; + +#define REDUCTION_OPERATION(NormInf, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL8) (CCTK_Cmplx16Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); +#endif + +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = NormInf + scalar; +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + break; + #endif + } + return num_points; +} + + +#ifdef CCTK_COMPLEX8 +int LocalReduce_NormInf_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts, int num_points, int * actual_iters_per_dim, int * iters_per_dim, int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; + +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL8) (CCTK_Cmplx16Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); +#endif + +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = NormInf + scalar; +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + 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_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, 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: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im; + +#define REDUCTION_OPERATION(NormInf, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL8) (CCTK_Cmplx16Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); +#endif + +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = NormInf + scalar; +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im; + +#define REDUCTION_OPERATION(NormInf, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL8) (CCTK_Cmplx16Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); +#endif + +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = NormInf + scalar; +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im; + +#define REDUCTION_OPERATION(NormInf, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL8) (CCTK_Cmplx16Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); +#endif + +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = NormInf + scalar; +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im; + +#define REDUCTION_OPERATION(NormInf, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL8) (CCTK_Cmplx16Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); +#endif + +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = NormInf + scalar; +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + break; + #endif + } + return num_points; +} +#endif + +#ifdef CCTK_COMPLEX16 +int LocalReduce_NormInf_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts, int num_points, int * actual_iters_per_dim, int * iters_per_dim, int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; + +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL8) (CCTK_Cmplx16Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); +#endif + +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = NormInf + scalar; +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + 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_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, 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: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im; + +#define REDUCTION_OPERATION(NormInf, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL8) (CCTK_Cmplx16Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); +#endif + +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = NormInf + scalar; +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im; + +#define REDUCTION_OPERATION(NormInf, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL8) (CCTK_Cmplx16Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); +#endif + +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = NormInf + scalar; +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im; + +#define REDUCTION_OPERATION(NormInf, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL8) (CCTK_Cmplx16Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); +#endif + +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = NormInf + scalar; +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im; + +#define REDUCTION_OPERATION(NormInf, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL8) (CCTK_Cmplx16Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); +#endif + +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = NormInf + scalar; +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + break; + #endif + } + return num_points; +} +#endif + +#ifdef CCTK_COMPLEX32 +int LocalReduce_NormInf_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts, int num_points, int * actual_iters_per_dim, int * iters_per_dim, int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; + +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL8) (CCTK_Cmplx16Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); +#endif + +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = NormInf + scalar; +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_CHAR: + 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; + 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_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, 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: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im; + +#define REDUCTION_OPERATION(NormInf, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL8) (CCTK_Cmplx16Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); +#endif + +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = NormInf + scalar; +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #ifdef CCTK_COMPLEX8 + case CCTK_VARIABLE_COMPLEX8: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im; + +#define REDUCTION_OPERATION(NormInf, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL8) (CCTK_Cmplx16Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); +#endif + +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = NormInf + scalar; +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX16 + case CCTK_VARIABLE_COMPLEX16: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im; + +#define REDUCTION_OPERATION(NormInf, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL8) (CCTK_Cmplx16Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); +#endif + +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = NormInf + scalar; +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + + break; + #endif + #ifdef CCTK_COMPLEX32 + case CCTK_VARIABLE_COMPLEX32: +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP +#ifdef ABS +#undef ABS +#endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) +#ifdef MAX +#undef MAX +#endif +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) + +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im; + +#define REDUCTION_OPERATION(NormInf, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); +#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; +#define EXTRA_STEP(a, b) + + 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) +#undef REDUCTION_OPERATION +#undef REDUCTION_INITIAL +#undef EXTRA_STEP + +#ifdef CCTK_REAL_PRECISION_4 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_8 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL8) (CCTK_Cmplx16Abs(typed_vdata[sum_indices])); +#elif CCTK_REAL_PRECISION_16 +#undef REDUCTION_PREOP_CAST +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); +#endif + +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = NormInf + scalar; +#define REDUCTION_INITIAL(num) num = 0; +#define EXTRA_STEP(a, b) + break; + #endif + } + return num_points; +} +#endif + + +#ifdef __cplusplus +} +#endif -- cgit v1.2.3