From 80baf9bbe8450673af26367f7d523ea8d1b905b3 Mon Sep 17 00:00:00 2001 From: eschnett Date: Sun, 3 Mar 2013 22:25:23 +0000 Subject: Disable (broken) support for complex numbers Disable (broken) support for complex numbers in anticipation of the upcoming complex number re-write in the flesh. git-svn-id: http://svn.cactuscode.org/arrangements/CactusNumerical/LocalReduce/trunk@103 7daa882c-dc44-4453-834e-278d26b18e6a --- src/AvgFunctions.c | 5626 +++++++++++++++++------------------ src/CountFunctions.c | 5602 +++++++++++++++++------------------ src/MaxFunctions.c | 5626 +++++++++++++++++------------------ src/MinFunctions.c | 5602 +++++++++++++++++------------------ src/Norm1Functions.c | 6392 ++++++++++++++++++++-------------------- src/Norm2Functions.c | 6962 ++++++++++++++++++++++---------------------- src/Norm3Functions.c | 6942 ++++++++++++++++++++++---------------------- src/Norm4Functions.c | 7178 ++++++++++++++++++++++----------------------- src/NormInfFunctions.c | 7566 ++++++++++++++++++++++++------------------------ src/ReductionAvg.c | 124 +- src/ReductionCount.c | 36 +- src/ReductionMax.c | 36 +- src/ReductionMin.c | 36 +- src/ReductionNorm1.c | 124 +- src/ReductionNorm2.c | 224 +- src/ReductionNorm3.c | 224 +- src/ReductionNorm4.c | 224 +- src/ReductionNormInf.c | 36 +- src/ReductionSum.c | 36 +- src/SumFunctions.c | 5602 +++++++++++++++++------------------ 20 files changed, 32099 insertions(+), 32099 deletions(-) diff --git a/src/AvgFunctions.c b/src/AvgFunctions.c index b2c892a..81608ce 100644 --- a/src/AvgFunctions.c +++ b/src/AvgFunctions.c @@ -89,170 +89,170 @@ int LocalReduce_Avg_BYTE(int i, int weight_on, const void * const weight, CCTK_I ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); @@ -330,167 +330,167 @@ int LocalReduce_Avg_INT(int i, int weight_on, const void * const weight, CCTK_IN ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -568,186 +568,186 @@ int LocalReduce_Avg_INT1(int i, int weight_on, const void * const weight, CCTK_I ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} +#endif -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) +#ifdef CCTK_VARIABLE_INT2 +int LocalReduce_Avg_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef CCTK_VARIABLE_INT2 -int LocalReduce_Avg_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -809,169 +809,169 @@ int LocalReduce_Avg_INT2(int i, int weight_on, const void * const weight, CCTK_I ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -1050,71 +1050,187 @@ int LocalReduce_Avg_INT4(int i, int weight_on, const void * const weight, CCTK_I ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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]; +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} #endif -#define REDUCTION_OPERATION(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) +#ifdef CCTK_VARIABLE_INT8 +int LocalReduce_Avg_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL @@ -1128,91 +1244,216 @@ int LocalReduce_Avg_INT4(int i, int weight_on, const void * const weight, CCTK_I #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -1220,8 +1461,7 @@ int LocalReduce_Avg_INT4(int i, int weight_on, const void * const weight, CCTK_I } #endif -#ifdef CCTK_VARIABLE_INT8 -int LocalReduce_Avg_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +int LocalReduce_Avg_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -1248,114 +1488,229 @@ int LocalReduce_Avg_INT8(int i, int weight_on, const void * const weight, CCTK_I { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) +#ifdef CCTK_VARIABLE_REAL4 +int LocalReduce_Avg_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL @@ -1369,91 +1724,216 @@ int LocalReduce_Avg_INT8(int i, int weight_on, const void * const weight, CCTK_I #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -1461,7 +1941,8 @@ int LocalReduce_Avg_INT8(int i, int weight_on, const void * const weight, CCTK_I } #endif -int LocalReduce_Avg_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef CCTK_VARIABLE_REAL8 +int LocalReduce_Avg_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -1488,220 +1969,222 @@ int LocalReduce_Avg_REAL(int i, int weight_on, const void * const weight, CCTK_I { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ + +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); return 0; } +#endif -#ifdef CCTK_VARIABLE_REAL4 -int LocalReduce_Avg_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef HAVE_CCTK_REAL16 +int LocalReduce_Avg_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -1728,212 +2211,212 @@ int LocalReduce_Avg_REAL4(int i, int weight_on, const void * const weight, CCTK_ { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -1941,1511 +2424,1028 @@ int LocalReduce_Avg_REAL4(int i, int weight_on, const void * const weight, CCTK_ } #endif -#ifdef CCTK_VARIABLE_REAL8 -int LocalReduce_Avg_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * 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_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; - -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_REAL16 -int LocalReduce_Avg_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * 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_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -int LocalReduce_Avg_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * 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_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} - - -#ifdef HAVE_CCTK_COMPLEX8 -int LocalReduce_Avg_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * 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_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_COMPLEX16 -int LocalReduce_Avg_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * 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_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_COMPLEX32 -int LocalReduce_Avg_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * 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_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif +/* int LocalReduce_Avg_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * 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_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ + + +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* int LocalReduce_Avg_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * 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_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ +/* #endif */ + +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* int LocalReduce_Avg_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * 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_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ +/* #endif */ + +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* int LocalReduce_Avg_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * 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_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(avg, scalar) avg = CCTK_CmplxAdd( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(avg, scalar) avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx8Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(avg, scalar) avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx16Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(avg, scalar) avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_Cmplx32Add( avg, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(avg, scalar) avg = avg + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) avg = avg + weight * scalar; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ +/* #endif */ #ifdef __cplusplus diff --git a/src/CountFunctions.c b/src/CountFunctions.c index 8c10d0a..dcc0d19 100644 --- a/src/CountFunctions.c +++ b/src/CountFunctions.c @@ -87,170 +87,170 @@ int LocalReduce_Count_BYTE(int i, int weight_on, const void * const weight, CCTK ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } return num_points; } @@ -325,167 +325,167 @@ int LocalReduce_Count_INT(int i, int weight_on, const void * const weight, CCTK_ ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } return num_points; } @@ -561,184 +561,184 @@ int LocalReduce_Count_INT1(int i, int weight_on, const void * const weight, CCTK ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + return num_points; +} +#endif -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) +#ifdef HAVE_CCTK_INT2 +int LocalReduce_Count_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} -#endif - -#ifdef HAVE_CCTK_INT2 -int LocalReduce_Count_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -800,169 +800,169 @@ int LocalReduce_Count_INT2(int i, int weight_on, const void * const weight, CCTK ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } return num_points; } @@ -1039,71 +1039,185 @@ int LocalReduce_Count_INT4(int i, int weight_on, const void * const weight, CCTK ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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]; +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + return num_points; +} #endif -#define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) +#ifdef HAVE_CCTK_INT8 +int LocalReduce_Count_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL @@ -1117,98 +1231,222 @@ int LocalReduce_Count_INT4(int i, int weight_on, const void * const weight, CCTK #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } return num_points; } #endif -#ifdef HAVE_CCTK_INT8 -int LocalReduce_Count_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +int LocalReduce_Count_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -1235,114 +1473,227 @@ int LocalReduce_Count_INT8(int i, int weight_on, const void * const weight, CCTK { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + return num_points; +} -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) +#ifdef HAVE_CCTK_REAL4 +int LocalReduce_Count_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL @@ -1356,97 +1707,223 @@ int LocalReduce_Count_INT8(int i, int weight_on, const void * const weight, CCTK #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } return num_points; } #endif -int LocalReduce_Count_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef HAVE_CCTK_REAL8 +int LocalReduce_Count_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -1473,218 +1950,220 @@ int LocalReduce_Count_REAL(int i, int weight_on, const void * const weight, CCTK { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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]; +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ + +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + return num_points; +} #endif -#define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} -#ifdef HAVE_CCTK_REAL4 -int LocalReduce_Count_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef HAVE_CCTK_REAL16 +int LocalReduce_Count_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -1711,1710 +2190,1231 @@ int LocalReduce_Count_REAL4(int i, int weight_on, const void * const weight, CCT { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } return num_points; } #endif -#ifdef HAVE_CCTK_REAL8 -int LocalReduce_Count_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; - -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} -#endif - -#ifdef HAVE_CCTK_REAL16 -int LocalReduce_Count_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} -#endif - -int LocalReduce_Count_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} - - -#ifdef HAVE_CCTK_COMPLEX8 -int LocalReduce_Count_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} -#endif - -#ifdef HAVE_CCTK_COMPLEX16 -int LocalReduce_Count_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} -#endif - -#ifdef HAVE_CCTK_COMPLEX32 -int LocalReduce_Count_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Count, scalar) (Count).Re = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Count, scalar) Count = num_points; -#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} -#endif +/* int LocalReduce_Count_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* return num_points; */ +/* } */ + + +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* int LocalReduce_Count_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* return num_points; */ +/* } */ +/* #endif */ + +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* int LocalReduce_Count_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* return num_points; */ +/* } */ +/* #endif */ + +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* int LocalReduce_Count_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Count, scalar) (Count).Re = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points; */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Count, scalar) Count = num_points; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* return num_points; */ +/* } */ +/* #endif */ #ifdef __cplusplus diff --git a/src/MaxFunctions.c b/src/MaxFunctions.c index 726d6bd..e5bd382 100644 --- a/src/MaxFunctions.c +++ b/src/MaxFunctions.c @@ -89,170 +89,170 @@ int LocalReduce_Max_BYTE(int i, int weight_on, const void * const weight, CCTK_I ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - break; - #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); @@ -330,167 +330,167 @@ int LocalReduce_Max_INT(int i, int weight_on, const void * const weight, CCTK_IN ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - break; - #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -568,186 +568,186 @@ int LocalReduce_Max_INT1(int i, int weight_on, const void * const weight, CCTK_I ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} +#endif -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) +#ifdef CCTK_VARIABLE_INT2 +int LocalReduce_Max_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef CCTK_VARIABLE_INT2 -int LocalReduce_Max_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -809,169 +809,169 @@ int LocalReduce_Max_INT2(int i, int weight_on, const void * const weight, CCTK_I ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - break; - #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -1050,71 +1050,187 @@ int LocalReduce_Max_INT4(int i, int weight_on, const void * const weight, CCTK_I ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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]; +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} #endif -#define REDUCTION_OPERATION(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) +#ifdef CCTK_VARIABLE_INT8 +int LocalReduce_Max_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL @@ -1128,91 +1244,216 @@ int LocalReduce_Max_INT4(int i, int weight_on, const void * const weight, CCTK_I #define REDUCTION_INITIAL(num) num = typed_vdata[0]; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -1220,8 +1461,7 @@ int LocalReduce_Max_INT4(int i, int weight_on, const void * const weight, CCTK_I } #endif -#ifdef CCTK_VARIABLE_INT8 -int LocalReduce_Max_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +int LocalReduce_Max_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -1248,114 +1488,229 @@ int LocalReduce_Max_INT8(int i, int weight_on, const void * const weight, CCTK_I { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) +#ifdef CCTK_VARIABLE_REAL4 +int LocalReduce_Max_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL @@ -1369,91 +1724,216 @@ int LocalReduce_Max_INT8(int i, int weight_on, const void * const weight, CCTK_I #define REDUCTION_INITIAL(num) num = typed_vdata[0]; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -1461,7 +1941,8 @@ int LocalReduce_Max_INT8(int i, int weight_on, const void * const weight, CCTK_I } #endif -int LocalReduce_Max_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef CCTK_VARIABLE_REAL8 +int LocalReduce_Max_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -1488,220 +1969,222 @@ int LocalReduce_Max_REAL(int i, int weight_on, const void * const weight, CCTK_I { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ + +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); return 0; } +#endif -#ifdef CCTK_VARIABLE_REAL4 -int LocalReduce_Max_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef HAVE_CCTK_REAL16 +int LocalReduce_Max_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -1728,212 +2211,212 @@ int LocalReduce_Max_REAL4(int i, int weight_on, const void * const weight, CCTK_ { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -1941,1511 +2424,1028 @@ int LocalReduce_Max_REAL4(int i, int weight_on, const void * const weight, CCTK_ } #endif -#ifdef CCTK_VARIABLE_REAL8 -int LocalReduce_Max_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; - -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_REAL16 -int LocalReduce_Max_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -int LocalReduce_Max_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} - - -#ifdef HAVE_CCTK_COMPLEX8 -int LocalReduce_Max_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_COMPLEX16 -int LocalReduce_Max_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_COMPLEX32 -int LocalReduce_Max_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; -#define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif +/* int LocalReduce_Max_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ + + +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* int LocalReduce_Max_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ +/* #endif */ + +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* int LocalReduce_Max_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ +/* #endif */ + +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* int LocalReduce_Max_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Max, scalar) if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = (typed_vdata[0]).Re; (num).Im = (typed_vdata[0]).Im; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Max, scalar) if (Max < scalar) Max = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if (ABS(weight)> SMALL_NUMBER) {if (Max < scalar) Max = scalar;} ; */ +/* #define REDUCTION_INITIAL(num) num = (typed_vdata[0]).Re; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ +/* #endif */ #ifdef __cplusplus diff --git a/src/MinFunctions.c b/src/MinFunctions.c index 998d666..24467c5 100644 --- a/src/MinFunctions.c +++ b/src/MinFunctions.c @@ -87,170 +87,170 @@ int LocalReduce_Min_BYTE(int i, int weight_on, const void * const weight, CCTK_I ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - break; - #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -327,167 +327,167 @@ int LocalReduce_Min_INT(int i, int weight_on, const void * const weight, CCTK_IN ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - break; - #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } return num_points; } @@ -563,184 +563,184 @@ int LocalReduce_Min_INT1(int i, int weight_on, const void * const weight, CCTK_I ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + return num_points; +} +#endif -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) +#ifdef HAVE_CCTK_INT2 +int LocalReduce_Min_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} -#endif - -#ifdef HAVE_CCTK_INT2 -int LocalReduce_Min_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -802,169 +802,169 @@ int LocalReduce_Min_INT2(int i, int weight_on, const void * const weight, CCTK_I ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - break; - #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } return num_points; } @@ -1041,71 +1041,185 @@ int LocalReduce_Min_INT4(int i, int weight_on, const void * const weight, CCTK_I ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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]; +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + return num_points; +} #endif -#define REDUCTION_OPERATION(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) +#ifdef HAVE_CCTK_INT8 +int LocalReduce_Min_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL @@ -1119,98 +1233,222 @@ int LocalReduce_Min_INT4(int i, int weight_on, const void * const weight, CCTK_I #define REDUCTION_INITIAL(num) num = typed_vdata[0]; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } return num_points; } #endif -#ifdef HAVE_CCTK_INT8 -int LocalReduce_Min_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +int LocalReduce_Min_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -1237,114 +1475,227 @@ int LocalReduce_Min_INT8(int i, int weight_on, const void * const weight, CCTK_I { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + return num_points; +} -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) +#ifdef HAVE_CCTK_REAL4 +int LocalReduce_Min_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL @@ -1358,97 +1709,223 @@ int LocalReduce_Min_INT8(int i, int weight_on, const void * const weight, CCTK_I #define REDUCTION_INITIAL(num) num = typed_vdata[0]; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } return num_points; } #endif -int LocalReduce_Min_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef HAVE_CCTK_REAL8 +int LocalReduce_Min_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -1475,218 +1952,220 @@ int LocalReduce_Min_REAL(int i, int weight_on, const void * const weight, CCTK_I { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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]; +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ + +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + return num_points; +} #endif -#define REDUCTION_OPERATION(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} -#ifdef HAVE_CCTK_REAL4 -int LocalReduce_Min_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef HAVE_CCTK_REAL16 +int LocalReduce_Min_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -1713,1710 +2192,1231 @@ int LocalReduce_Min_REAL4(int i, int weight_on, const void * const weight, CCTK_ { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } return num_points; } #endif -#ifdef HAVE_CCTK_REAL8 -int LocalReduce_Min_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; - -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} -#endif - -#ifdef HAVE_CCTK_REAL16 -int LocalReduce_Min_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} -#endif - -int LocalReduce_Min_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} - - -#ifdef HAVE_CCTK_COMPLEX8 -int LocalReduce_Min_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} -#endif - -#ifdef HAVE_CCTK_COMPLEX16 -int LocalReduce_Min_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} -#endif - -#ifdef HAVE_CCTK_COMPLEX32 -int LocalReduce_Min_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0]; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; -#define EXTRA_STEP(a, b) - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; -#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; -#define EXTRA_STEP(a, b) - - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; -#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; -#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} -#endif +/* int LocalReduce_Min_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* return num_points; */ +/* } */ + + +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* int LocalReduce_Min_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* return num_points; */ +/* } */ +/* #endif */ + +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* int LocalReduce_Min_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* return num_points; */ +/* } */ +/* #endif */ + +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* int LocalReduce_Min_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0]; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; */ +/* #define EXTRA_STEP(a, b) */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Min, scalar) if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;}; */ +/* #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im; */ +/* #define EXTRA_STEP(a, b) */ + +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Min, scalar) if (Min > scalar) Min = scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if(ABS(weight)>SMALL_NUMBER){if (Min > scalar) Min = scalar;}; */ +/* #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* return num_points; */ +/* } */ +/* #endif */ #ifdef __cplusplus diff --git a/src/Norm1Functions.c b/src/Norm1Functions.c index aabd7b6..6f607ec 100644 --- a/src/Norm1Functions.c +++ b/src/Norm1Functions.c @@ -92,202 +92,202 @@ int LocalReduce_Norm1_BYTE(int i, int weight_on, const void * const weight, CCTK ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); @@ -369,35 +369,217 @@ int LocalReduce_Norm1_INT(int i, int weight_on, const void * const weight, CCTK_ ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} + +#ifdef CCTK_INT1 +int LocalReduce_Norm1_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; + + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL @@ -415,37 +597,267 @@ int LocalReduce_Norm1_INT(int i, int weight_on, const void * const weight, CCTK_ #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef CCTK_INT11 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef CCTK_INT12 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef CCTK_INT14 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef CCTK_INT18 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} +#endif + +#ifdef CCTK_INT2 +int LocalReduce_Norm1_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; + + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL @@ -463,2049 +875,248 @@ int LocalReduce_Norm1_INT(int i, int weight_on, const void * const weight, CCTK_ #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} - -#ifdef CCTK_INT1 -int LocalReduce_Norm1_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef CCTK_INT11 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_INT12 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_INT14 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_INT18 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef CCTK_INT2 -int LocalReduce_Norm1_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef CCTK_INT21 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_INT22 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_INT24 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_INT28 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef CCTK_INT4 -int LocalReduce_Norm1_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef CCTK_INT8 -int LocalReduce_Norm1_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -int LocalReduce_Norm1_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} - -#ifdef CCTK_REAL4 -int LocalReduce_Norm1_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef CCTK_REAL8 -int LocalReduce_Norm1_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; - #ifdef CCTK_INT1 + #ifdef CCTK_INT21 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef CCTK_INT2 + #ifdef CCTK_INT22 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef CCTK_INT4 + #ifdef CCTK_INT24 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef CCTK_INT8 + #ifdef CCTK_INT28 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - + #ifdef CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - + #ifdef CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; - -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + #ifdef CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); @@ -2514,8 +1125,8 @@ int LocalReduce_Norm1_REAL8(int i, int weight_on, const void * const weight, CCT } #endif -#ifdef CCTK_REAL16 -int LocalReduce_Norm1_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef CCTK_INT4 +int LocalReduce_Norm1_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -2546,126 +1157,263 @@ int LocalReduce_Norm1_REAL16(int i, int weight_on, const void * const weight, CC { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } -#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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef ABS -#undef ABS + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} #endif -#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) +#ifdef CCTK_INT8 +int LocalReduce_Norm1_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL @@ -2683,107 +1431,248 @@ int LocalReduce_Norm1_REAL16(int i, int weight_on, const void * const weight, CC #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - + #ifdef CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + #ifdef CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); @@ -2792,7 +1681,7 @@ int LocalReduce_Norm1_REAL16(int i, int weight_on, const void * const weight, CC } #endif -int LocalReduce_Norm1_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +int LocalReduce_Norm1_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -2806,23 +1695,16 @@ int LocalReduce_Norm1_COMPLEX(int i, int weight_on, const void * const weight, C #undef WEIGHTED_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])); +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS #endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); +#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) @@ -2830,232 +1712,244 @@ int LocalReduce_Norm1_COMPLEX(int i, int weight_on, const void * const weight, C { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef ABS -#undef ABS -#endif -#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) - -#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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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(Norm1, scalar) Norm1 = Norm1 + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef ABS -#undef ABS -#endif -#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) - -#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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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(Norm1, scalar) Norm1 = Norm1 + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef ABS -#undef ABS -#endif -#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) - -#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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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(Norm1, scalar) Norm1 = Norm1 + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef ABS -#undef ABS -#endif -#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) - -#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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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(Norm1, scalar) Norm1 = Norm1 + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); @@ -3063,9 +1957,8 @@ int LocalReduce_Norm1_COMPLEX(int i, int weight_on, const void * const weight, C return 0; } - -#ifdef HAVE_CCTK_COMPLEX8 -int LocalReduce_Norm1_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef CCTK_REAL4 +int LocalReduce_Norm1_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -3079,13 +1972,16 @@ int LocalReduce_Norm1_COMPLEX8(int i, int weight_on, const void * const weight, #undef WEIGHTED_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)) -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); - -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); +#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) @@ -3093,192 +1989,244 @@ int LocalReduce_Norm1_COMPLEX8(int i, int weight_on, const void * const weight, { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef ABS -#undef ABS -#endif -#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) - -#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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); - -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef ABS -#undef ABS -#endif -#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) - -#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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); - -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef ABS -#undef ABS -#endif -#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) - -#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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); - -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef ABS -#undef ABS -#endif -#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) - -#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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); - -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); @@ -3287,8 +2235,8 @@ int LocalReduce_Norm1_COMPLEX8(int i, int weight_on, const void * const weight, } #endif -#ifdef HAVE_CCTK_COMPLEX16 -int LocalReduce_Norm1_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef CCTK_REAL8 +int LocalReduce_Norm1_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -3302,23 +2250,16 @@ int LocalReduce_Norm1_COMPLEX16(int i, int weight_on, const void * const weight, #undef WEIGHTED_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_Cmplx16Abs(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_Cmplx16Abs(typed_vdata[sum_indices])); +#undef REDUCTION_PREOP_CAST +#ifdef ABS +#undef ABS #endif +#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; +#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); +#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) @@ -3326,232 +2267,245 @@ int LocalReduce_Norm1_COMPLEX16(int i, int weight_on, const void * const weight, { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef ABS -#undef ABS -#endif -#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) - -#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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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(Norm1, scalar) Norm1 = Norm1 + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef ABS -#undef ABS -#endif -#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) - -#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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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(Norm1, scalar) Norm1 = Norm1 + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef ABS -#undef ABS -#endif -#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) - -#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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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(Norm1, scalar) Norm1 = Norm1 + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef ABS -#undef ABS -#endif -#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) - -#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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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(Norm1, scalar) Norm1 = Norm1 + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ + +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); @@ -3560,8 +2514,8 @@ int LocalReduce_Norm1_COMPLEX16(int i, int weight_on, const void * const weight, } #endif -#ifdef HAVE_CCTK_COMPLEX32 -int LocalReduce_Norm1_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef CCTK_REAL16 +int LocalReduce_Norm1_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -3575,13 +2529,16 @@ int LocalReduce_Norm1_COMPLEX32(int i, int weight_on, const void * const weight, #undef WEIGHTED_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)) -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); - -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); +#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) @@ -3589,192 +2546,244 @@ int LocalReduce_Norm1_COMPLEX32(int i, int weight_on, const void * const weight, { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef ABS -#undef ABS -#endif -#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) - -#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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); - -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef ABS -#undef ABS -#endif -#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) - -#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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx8Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); - -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef ABS -#undef ABS -#endif -#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) - -#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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx16Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); - -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef ABS -#undef ABS -#endif -#define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) - -#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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx32Add( Norm1, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); - -#define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); @@ -3783,6 +2792,997 @@ int LocalReduce_Norm1_COMPLEX32(int i, int weight_on, const void * const weight, } #endif +/* int LocalReduce_Norm1_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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(Norm1, scalar) Norm1 = Norm1 + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef ABS */ +/* #undef ABS */ +/* #endif */ +/* #define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) */ + +/* #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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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(Norm1, scalar) Norm1 = Norm1 + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef ABS */ +/* #undef ABS */ +/* #endif */ +/* #define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) */ + +/* #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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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(Norm1, scalar) Norm1 = Norm1 + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef ABS */ +/* #undef ABS */ +/* #endif */ +/* #define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) */ + +/* #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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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(Norm1, scalar) Norm1 = Norm1 + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef ABS */ +/* #undef ABS */ +/* #endif */ +/* #define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) */ + +/* #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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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(Norm1, scalar) Norm1 = Norm1 + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ + +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ + + +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* int LocalReduce_Norm1_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); */ + +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef ABS */ +/* #undef ABS */ +/* #endif */ +/* #define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) */ + +/* #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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); */ + +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef ABS */ +/* #undef ABS */ +/* #endif */ +/* #define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) */ + +/* #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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); */ + +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef ABS */ +/* #undef ABS */ +/* #endif */ +/* #define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) */ + +/* #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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); */ + +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef ABS */ +/* #undef ABS */ +/* #endif */ +/* #define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) */ + +/* #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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); */ + +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ + +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ +/* #endif */ + +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* int LocalReduce_Norm1_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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_Cmplx16Abs(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_Cmplx16Abs(typed_vdata[sum_indices])); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef ABS */ +/* #undef ABS */ +/* #endif */ +/* #define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) */ + +/* #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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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(Norm1, scalar) Norm1 = Norm1 + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef ABS */ +/* #undef ABS */ +/* #endif */ +/* #define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) */ + +/* #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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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(Norm1, scalar) Norm1 = Norm1 + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef ABS */ +/* #undef ABS */ +/* #endif */ +/* #define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) */ + +/* #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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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(Norm1, scalar) Norm1 = Norm1 + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef ABS */ +/* #undef ABS */ +/* #endif */ +/* #define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) */ + +/* #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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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(Norm1, scalar) Norm1 = Norm1 + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ + +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ +/* #endif */ + +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* int LocalReduce_Norm1_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); */ + +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef ABS */ +/* #undef ABS */ +/* #endif */ +/* #define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) */ + +/* #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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); */ + +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef ABS */ +/* #undef ABS */ +/* #endif */ +/* #define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) */ + +/* #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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx8Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); */ + +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef ABS */ +/* #undef ABS */ +/* #endif */ +/* #define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) */ + +/* #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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx16Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); */ + +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef ABS */ +/* #undef ABS */ +/* #endif */ +/* #define ABS(x) ((CCTK_REAL)(x) < 0 ? -(x) : (x)) */ + +/* #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(Norm1, scalar) (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_Cmplx32Add( Norm1, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); */ + +/* #define REDUCTION_OPERATION(Norm1, scalar) Norm1 = Norm1 + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) Norm1 = Norm1 + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ + +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ +/* #endif */ + #ifdef _cplusplus } diff --git a/src/Norm2Functions.c b/src/Norm2Functions.c index d395f0f..63933c5 100644 --- a/src/Norm2Functions.c +++ b/src/Norm2Functions.c @@ -92,203 +92,203 @@ int LocalReduce_Norm2_BYTE(int i, int weight_on, const void * const weight, CCTK ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -369,83 +369,217 @@ int LocalReduce_Norm2_INT(int i, int weight_on, const void * const weight, CCTK_ ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) +#ifdef HAVE_CCTK_INT1 +int LocalReduce_Norm2_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL @@ -463,162 +597,28 @@ int LocalReduce_Norm2_INT(int i, int weight_on, const void * const weight, CCTK_ #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT11 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT12 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} - -#ifdef HAVE_CCTK_INT1 -int LocalReduce_Norm2_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT11 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT12 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT14 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + #ifdef HAVE_CCTK_INT14 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT18 @@ -644,202 +644,202 @@ int LocalReduce_Norm2_INT1(int i, int weight_on, const void * const weight, CCTK ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -852,2522 +852,272 @@ int LocalReduce_Norm2_INT2(int i, int weight_on, const void * const weight, CCTK { int iter = 0; int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT21 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT22 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT24 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT28 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_INT4 -int LocalReduce_Norm2_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_INT8 -int LocalReduce_Norm2_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -int LocalReduce_Norm2_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} - -#ifdef HAVE_CCTK_REAL4 -int LocalReduce_Norm2_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_REAL8 -int LocalReduce_Norm2_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; - -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_REAL16 -int LocalReduce_Norm2_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -int LocalReduce_Norm2_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) CCTK_CmplxAbs(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_CmplxAbs(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_CmplxAbs(typed_vdata[sum_indices]); -#endif - -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} - - -#ifdef HAVE_CCTK_COMPLEX8 -int LocalReduce_Norm2_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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; + int flag, product, j, k; -#define REDUCTION_OPERATION(Norm2, scalar) scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; -#define EXTRA_STEP(a, b) + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef SQR #undef SQR #endif #define SQR(x) ((x) * (x)) -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT21 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT22 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT24 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT28 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -3375,8 +1125,8 @@ int LocalReduce_Norm2_COMPLEX8(int i, int weight_on, const void * const weight, } #endif -#ifdef HAVE_CCTK_COMPLEX16 -int LocalReduce_Norm2_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef HAVE_CCTK_INT4 +int LocalReduce_Norm2_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -3390,25 +1140,14 @@ int LocalReduce_Norm2_COMPLEX16(int i, int weight_on, const void * const weight, #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef SQR #undef SQR #endif #define SQR(x) ((x) * (x)) -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; @@ -3418,257 +1157,808 @@ int LocalReduce_Norm2_COMPLEX16(int i, int weight_on, const void * const weight, { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} #endif -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) +#ifdef HAVE_CCTK_INT8 +int LocalReduce_Norm2_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; -#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; + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#define REDUCTION_OPERATION(Norm2, scalar) scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef SQR #undef SQR #endif #define SQR(x) ((x) * (x)) -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} #endif -#define SQR(x) ((x) * (x)) -#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; +int LocalReduce_Norm2_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; -#define REDUCTION_OPERATION(Norm2, scalar) scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; -#define EXTRA_STEP(a, b) + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef SQR #undef SQR #endif #define SQR(x) ((x) * (x)) -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); return 0; } -#endif -#ifdef HAVE_CCTK_COMPLEX32 -int LocalReduce_Norm2_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef HAVE_CCTK_REAL4 +int LocalReduce_Norm2_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -3682,25 +1972,14 @@ int LocalReduce_Norm2_COMPLEX32(int i, int weight_on, const void * const weight, #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef SQR #undef SQR #endif #define SQR(x) ((x) * (x)) -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; @@ -3710,248 +1989,802 @@ int LocalReduce_Norm2_COMPLEX32(int i, int weight_on, const void * const weight, { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} #endif -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) +#ifdef HAVE_CCTK_REAL8 +int LocalReduce_Norm2_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; -#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; + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#define REDUCTION_OPERATION(Norm2, scalar) scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm2 = CCTK_Cmplx8Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef SQR #undef SQR #endif #define SQR(x) ((x) * (x)) -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ + +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} #endif -#define SQR(x) ((x) * (x)) -#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; +#ifdef HAVE_CCTK_REAL16 +int LocalReduce_Norm2_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; -#define REDUCTION_OPERATION(Norm2, scalar) scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); -#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; -#define EXTRA_STEP(a, b) + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef SQR #undef SQR #endif #define SQR(x) ((x) * (x)) -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#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(Norm2, scalar) scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef SQR -#undef SQR -#endif -#define SQR(x) ((x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - -#define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -3959,6 +2792,1173 @@ int LocalReduce_Norm2_COMPLEX32(int i, int weight_on, const void * const weight, } #endif +/* int LocalReduce_Norm2_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) CCTK_CmplxAbs(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_CmplxAbs(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_CmplxAbs(typed_vdata[sum_indices]); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ + + +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* int LocalReduce_Norm2_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ +/* #endif */ + +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* int LocalReduce_Norm2_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ +/* #endif */ + +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* int LocalReduce_Norm2_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm2 = CCTK_Cmplx8Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm2 = CCTK_Cmplx16Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #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(Norm2, scalar) scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm2 = CCTK_Cmplx32Add( Norm2, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef SQR */ +/* #undef SQR */ +/* #endif */ +/* #define SQR(x) ((x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm2, scalar) Norm2 = Norm2 + SQR(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) Norm2 = Norm2 + SQR(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ +/* #endif */ + #ifdef __cplusplus } diff --git a/src/Norm3Functions.c b/src/Norm3Functions.c index e644db8..681883f 100644 --- a/src/Norm3Functions.c +++ b/src/Norm3Functions.c @@ -97,202 +97,202 @@ int LocalReduce_Norm3_BYTE(int i, int weight_on, const void * const weight, CCTK ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -373,83 +373,216 @@ int LocalReduce_Norm3_INT(int i, int weight_on, const void * const weight, CCTK_ ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) +#ifdef HAVE_CCTK_INT1 +int LocalReduce_Norm3_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL @@ -467,161 +600,28 @@ int LocalReduce_Norm3_INT(int i, int weight_on, const void * const weight, CCTK_ #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT11 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT12 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} - -#ifdef HAVE_CCTK_INT1 -int LocalReduce_Norm3_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT11 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT12 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT14 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + #ifdef HAVE_CCTK_INT14 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT18 @@ -647,201 +647,201 @@ int LocalReduce_Norm3_INT1(int i, int weight_on, const void * const weight, CCTK ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -854,2515 +854,271 @@ int LocalReduce_Norm3_INT2(int i, int weight_on, const void * const weight, CCTK { int iter = 0; int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT21 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT22 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT24 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT28 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_INT4 -int LocalReduce_Norm3_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_INT8 -int LocalReduce_Norm3_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -int LocalReduce_Norm3_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} - -#ifdef HAVE_CCTK_REAL4 -int LocalReduce_Norm3_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_REAL8 -int LocalReduce_Norm3_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; - -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_REAL16 -int LocalReduce_Norm3_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -int LocalReduce_Norm3_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) CCTK_CmplxAbs(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_CmplxAbs(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_CmplxAbs(typed_vdata[sum_indices]); -#endif - -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) scalar = CCTK_Cmplx8Mul(scalar, CCTK_Cmplx8Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar, CCTK_Cmplx8Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) scalar = CCTK_Cmplx16Mul(scalar, CCTK_Cmplx16Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar, CCTK_Cmplx16Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) scalar = CCTK_Cmplx32Mul(scalar, CCTK_Cmplx32Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar, CCTK_Cmplx32Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} - - -#ifdef HAVE_CCTK_COMPLEX8 -int LocalReduce_Norm3_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) scalar = CCTK_Cmplx8Mul(scalar, CCTK_Cmplx8Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar, CCTK_Cmplx8Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) scalar = CCTK_Cmplx16Mul(scalar, CCTK_Cmplx16Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar, CCTK_Cmplx16Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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; + int flag, product, j, k; -#define REDUCTION_OPERATION(Norm3, scalar) scalar = CCTK_Cmplx32Mul(scalar, CCTK_Cmplx32Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar, CCTK_Cmplx32Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; -#define EXTRA_STEP(a, b) + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef CUBE_ABS #undef CUBE_ABS #endif #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT21 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT22 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT24 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT28 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -3370,8 +1126,8 @@ int LocalReduce_Norm3_COMPLEX8(int i, int weight_on, const void * const weight, } #endif -#ifdef HAVE_CCTK_COMPLEX16 -int LocalReduce_Norm3_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef HAVE_CCTK_INT4 +int LocalReduce_Norm3_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -3385,25 +1141,14 @@ int LocalReduce_Norm3_COMPLEX16(int i, int weight_on, const void * const weight, #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef CUBE_ABS #undef CUBE_ABS #endif #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; @@ -3413,257 +1158,805 @@ int LocalReduce_Norm3_COMPLEX16(int i, int weight_on, const void * const weight, { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} #endif -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) +#ifdef HAVE_CCTK_INT8 +int LocalReduce_Norm3_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; -#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; + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#define REDUCTION_OPERATION(Norm3, scalar) scalar = CCTK_Cmplx8Mul(scalar, CCTK_Cmplx8Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar, CCTK_Cmplx8Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef CUBE_ABS #undef CUBE_ABS #endif #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) scalar = CCTK_Cmplx16Mul(scalar, CCTK_Cmplx16Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar, CCTK_Cmplx16Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} #endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) -#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; +int LocalReduce_Norm3_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; -#define REDUCTION_OPERATION(Norm3, scalar) scalar = CCTK_Cmplx32Mul(scalar, CCTK_Cmplx32Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar, CCTK_Cmplx32Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; -#define EXTRA_STEP(a, b) + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef CUBE_ABS #undef CUBE_ABS #endif #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); return 0; } -#endif -#ifdef HAVE_CCTK_COMPLEX32 -int LocalReduce_Norm3_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef HAVE_CCTK_REAL4 +int LocalReduce_Norm3_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -3677,25 +1970,14 @@ int LocalReduce_Norm3_COMPLEX32(int i, int weight_on, const void * const weight, #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef CUBE_ABS #undef CUBE_ABS #endif #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; @@ -3705,248 +1987,799 @@ int LocalReduce_Norm3_COMPLEX32(int i, int weight_on, const void * const weight, { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} #endif -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) +#ifdef HAVE_CCTK_REAL8 +int LocalReduce_Norm3_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; -#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; + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#define REDUCTION_OPERATION(Norm3, scalar) scalar = CCTK_Cmplx8Mul(scalar, CCTK_Cmplx8Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar, CCTK_Cmplx8Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef CUBE_ABS #undef CUBE_ABS #endif #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ + +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} #endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) -#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; +#ifdef HAVE_CCTK_REAL16 +int LocalReduce_Norm3_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; -#define REDUCTION_OPERATION(Norm3, scalar) scalar = CCTK_Cmplx16Mul(scalar, CCTK_Cmplx16Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar, CCTK_Cmplx16Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); -#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; -#define EXTRA_STEP(a, b) + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef CUBE_ABS #undef CUBE_ABS #endif #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#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(Norm3, scalar) scalar = CCTK_Cmplx32Mul(scalar, CCTK_Cmplx32Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar, CCTK_Cmplx32Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef CUBE_ABS -#undef CUBE_ABS -#endif -#define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); -#endif - -#define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -3954,6 +2787,1173 @@ int LocalReduce_Norm3_COMPLEX32(int i, int weight_on, const void * const weight, } #endif +/* int LocalReduce_Norm3_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) CCTK_CmplxAbs(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_CmplxAbs(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_CmplxAbs(typed_vdata[sum_indices]); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) scalar = CCTK_Cmplx8Mul(scalar, CCTK_Cmplx8Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar, CCTK_Cmplx8Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) scalar = CCTK_Cmplx16Mul(scalar, CCTK_Cmplx16Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar, CCTK_Cmplx16Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) scalar = CCTK_Cmplx32Mul(scalar, CCTK_Cmplx32Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar, CCTK_Cmplx32Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ + + +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* int LocalReduce_Norm3_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) scalar = CCTK_Cmplx8Mul(scalar, CCTK_Cmplx8Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar, CCTK_Cmplx8Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) scalar = CCTK_Cmplx16Mul(scalar, CCTK_Cmplx16Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar, CCTK_Cmplx16Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) scalar = CCTK_Cmplx32Mul(scalar, CCTK_Cmplx32Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar, CCTK_Cmplx32Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ +/* #endif */ + +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* int LocalReduce_Norm3_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) scalar = CCTK_Cmplx8Mul(scalar, CCTK_Cmplx8Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar, CCTK_Cmplx8Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) scalar = CCTK_Cmplx16Mul(scalar, CCTK_Cmplx16Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar, CCTK_Cmplx16Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) scalar = CCTK_Cmplx32Mul(scalar, CCTK_Cmplx32Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar, CCTK_Cmplx32Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ +/* #endif */ + +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* int LocalReduce_Norm3_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) scalar = CCTK_Cmplx8Mul(scalar, CCTK_Cmplx8Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar, CCTK_Cmplx8Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx8Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) scalar = CCTK_Cmplx16Mul(scalar, CCTK_Cmplx16Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar, CCTK_Cmplx16Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx16Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #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(Norm3, scalar) scalar = CCTK_Cmplx32Mul(scalar, CCTK_Cmplx32Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar, CCTK_Cmplx32Mul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_Cmplx32Add( Norm3, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef CUBE_ABS */ +/* #undef CUBE_ABS */ +/* #endif */ +/* #define CUBE_ABS(x) ((CCTK_REAL)(x) < 0 ? -((x) * (x) * (x)) : (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) ((typed_vdata[sum_indices]).Re); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) ((typed_vdata[sum_indices]).Re); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm3, scalar) Norm3 = Norm3 + CUBE_ABS(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) Norm3 = Norm3 + CUBE_ABS(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ +/* #endif */ + #ifdef __cplusplus } diff --git a/src/Norm4Functions.c b/src/Norm4Functions.c index 17651da..8c39b74 100644 --- a/src/Norm4Functions.c +++ b/src/Norm4Functions.c @@ -92,202 +92,202 @@ int LocalReduce_Norm4_BYTE(int i, int weight_on, const void * const weight, CCTK ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -368,35 +368,216 @@ int LocalReduce_Norm4_INT(int i, int weight_on, const void * const weight, CCTK_ ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} + +#ifdef HAVE_CCTK_INT1 +int LocalReduce_Norm4_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; + + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL @@ -414,37 +595,266 @@ int LocalReduce_Norm4_INT(int i, int weight_on, const void * const weight, CCTK_ #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT11 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT12 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT14 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT18 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} +#endif + +#ifdef HAVE_CCTK_INT2 +int LocalReduce_Norm4_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; + + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL @@ -462,2955 +872,248 @@ int LocalReduce_Norm4_INT(int i, int weight_on, const void * const weight, CCTK_ #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} - -#ifdef HAVE_CCTK_INT1 -int LocalReduce_Norm4_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT11 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT12 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT14 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT18 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_INT2 -int LocalReduce_Norm4_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT21 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT22 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT24 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT28 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_INT4 -int LocalReduce_Norm4_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_INT8 -int LocalReduce_Norm4_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -int LocalReduce_Norm4_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} - -#ifdef HAVE_CCTK_REAL4 -int LocalReduce_Norm4_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_REAL8 -int LocalReduce_Norm4_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; - -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_REAL16 -int LocalReduce_Norm4_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -int LocalReduce_Norm4_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER2(x) ((x) * (x)) -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) CCTK_CmplxAbs(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_CmplxAbs(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_CmplxAbs(typed_vdata[sum_indices]); -#endif - -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER2 -#undef POWER2 -#endif -#ifdef POWER4 -#undef POWER4 -#endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER2(x) ((x)*(x)) -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER2(x) ((x) * (x)) -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#endif - -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) scalar = CCTK_Cmplx8Mul(scalar,scalar); scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar,scalar); scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER2(x) ((x) * (x)) -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#endif - -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) scalar = CCTK_Cmplx16Mul(scalar,scalar); scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar,scalar); scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER2(x) ((x) * (x)) -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#endif - -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) scalar = CCTK_Cmplx32Mul(scalar,scalar); scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar,scalar); scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER2(x) ((x) * (x)) -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#endif - -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} - - -#ifdef HAVE_CCTK_COMPLEX8 -int LocalReduce_Norm4_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER2(x) ((x) * (x)) -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#endif - -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; - #ifdef HAVE_CCTK_INT1 + #ifdef HAVE_CCTK_INT21 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_INT2 + #ifdef HAVE_CCTK_INT22 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_INT4 + #ifdef HAVE_CCTK_INT24 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_INT8 + #ifdef HAVE_CCTK_INT28 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER2(x) ((x) * (x)) -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#endif - -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) scalar = CCTK_Cmplx8Mul(scalar,scalar); scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar,scalar); scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER2(x) ((x) * (x)) -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#endif - -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) scalar = CCTK_Cmplx16Mul(scalar,scalar); scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar,scalar); scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER2(x) ((x) * (x)) -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#endif - -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) scalar = CCTK_Cmplx32Mul(scalar,scalar); scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar,scalar); scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER2(x) ((x) * (x)) -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#endif - -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -3418,8 +1121,8 @@ int LocalReduce_Norm4_COMPLEX8(int i, int weight_on, const void * const weight, } #endif -#ifdef HAVE_CCTK_COMPLEX16 -int LocalReduce_Norm4_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef HAVE_CCTK_INT4 +int LocalReduce_Norm4_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -3433,29 +1136,14 @@ int LocalReduce_Norm4_COMPLEX16(int i, int weight_on, const void * const weight, #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef POWER4 #undef POWER4 #endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER2(x) ((x) * (x)) #define POWER4(x) ((x) * (x) * (x) * (x)) -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#endif - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; @@ -3465,276 +1153,805 @@ int LocalReduce_Norm4_COMPLEX16(int i, int weight_on, const void * const weight, { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER2(x) ((x) * (x)) -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} #endif -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) +#ifdef HAVE_CCTK_INT8 +int LocalReduce_Norm4_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; -#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; + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#define REDUCTION_OPERATION(Norm4, scalar) scalar = CCTK_Cmplx8Mul(scalar,scalar); scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar,scalar); scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef POWER4 #undef POWER4 #endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER2(x) ((x) * (x)) #define POWER4(x) ((x) * (x) * (x) * (x)) -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#endif - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#ifdef POWER2 -#undef POWER2 + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} #endif -#define POWER4(x) ((x) * (x) * (x) * (x)) -#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; +int LocalReduce_Norm4_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; -#define REDUCTION_OPERATION(Norm4, scalar) scalar = CCTK_Cmplx16Mul(scalar,scalar); scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar,scalar); scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; -#define EXTRA_STEP(a, b) + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef POWER4 #undef POWER4 #endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER2(x) ((x) * (x)) #define POWER4(x) ((x) * (x) * (x) * (x)) -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#endif - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) scalar = CCTK_Cmplx32Mul(scalar,scalar); scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar,scalar); scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER2(x) ((x) * (x)) -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#endif - -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); return 0; } -#endif -#ifdef HAVE_CCTK_COMPLEX32 -int LocalReduce_Norm4_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef HAVE_CCTK_REAL4 +int LocalReduce_Norm4_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -3748,29 +1965,14 @@ int LocalReduce_Norm4_COMPLEX32(int i, int weight_on, const void * const weight, #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef POWER4 #undef POWER4 #endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER2(x) ((x) * (x)) #define POWER4(x) ((x) * (x) * (x) * (x)) -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#endif - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; @@ -3780,264 +1982,799 @@ int LocalReduce_Norm4_COMPLEX32(int i, int weight_on, const void * const weight, { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER2(x) ((x) * (x)) -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} #endif -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) +#ifdef HAVE_CCTK_REAL8 +int LocalReduce_Norm4_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; -#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; + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#define REDUCTION_OPERATION(Norm4, scalar) scalar = CCTK_Cmplx8Mul(scalar,scalar); scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar,scalar); scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm4 = CCTK_Cmplx8Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef POWER4 #undef POWER4 #endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER2(x) ((x) * (x)) #define POWER4(x) ((x) * (x) * (x) * (x)) -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#endif - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ + +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} #endif -#define POWER4(x) ((x) * (x) * (x) * (x)) -#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; +#ifdef HAVE_CCTK_REAL16 +int LocalReduce_Norm4_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; -#define REDUCTION_OPERATION(Norm4, scalar) scalar = CCTK_Cmplx16Mul(scalar,scalar); scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar,scalar); scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); -#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0; -#define EXTRA_STEP(a, b) + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef POWER4 #undef POWER4 #endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER2(x) ((x) * (x)) #define POWER4(x) ((x) * (x) * (x) * (x)) -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#endif - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#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(Norm4, scalar) scalar = CCTK_Cmplx32Mul(scalar,scalar); scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar,scalar); scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#ifdef POWER4 -#undef POWER4 -#endif -#ifdef POWER2 -#undef POWER2 -#endif -#define POWER2(x) ((x) * (x)) -#define POWER4(x) ((x) * (x) * (x) * (x)) - -#ifdef CCTK_REAL_PRECISION_4 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); -#endif - -#define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -4045,6 +2782,1269 @@ int LocalReduce_Norm4_COMPLEX32(int i, int weight_on, const void * const weight, } #endif +/* int LocalReduce_Norm4_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER2(x) ((x) * (x)) */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) CCTK_CmplxAbs(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_CmplxAbs(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_CmplxAbs(typed_vdata[sum_indices]); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER2(x) ((x)*(x)) */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER2(x) ((x) * (x)) */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) scalar = CCTK_Cmplx8Mul(scalar,scalar); scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar,scalar); scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER2(x) ((x) * (x)) */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) scalar = CCTK_Cmplx16Mul(scalar,scalar); scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar,scalar); scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER2(x) ((x) * (x)) */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) scalar = CCTK_Cmplx32Mul(scalar,scalar); scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar,scalar); scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER2(x) ((x) * (x)) */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ + + +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* int LocalReduce_Norm4_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER2(x) ((x) * (x)) */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER2(x) ((x) * (x)) */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) scalar = CCTK_Cmplx8Mul(scalar,scalar); scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar,scalar); scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER2(x) ((x) * (x)) */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) scalar = CCTK_Cmplx16Mul(scalar,scalar); scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar,scalar); scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER2(x) ((x) * (x)) */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) scalar = CCTK_Cmplx32Mul(scalar,scalar); scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar,scalar); scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER2(x) ((x) * (x)) */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ +/* #endif */ + +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* int LocalReduce_Norm4_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER2(x) ((x) * (x)) */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER2(x) ((x) * (x)) */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) scalar = CCTK_Cmplx8Mul(scalar,scalar); scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar,scalar); scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER2(x) ((x) * (x)) */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) scalar = CCTK_Cmplx16Mul(scalar,scalar); scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar,scalar); scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER2(x) ((x) * (x)) */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) scalar = CCTK_Cmplx32Mul(scalar,scalar); scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar,scalar); scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER2(x) ((x) * (x)) */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ +/* #endif */ + +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* int LocalReduce_Norm4_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER2(x) ((x) * (x)) */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER2(x) ((x) * (x)) */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) scalar = CCTK_Cmplx8Mul(scalar,scalar); scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx8Mul(scalar,scalar); scalar = CCTK_Cmplx8Mul(scalar,scalar);Norm4 = CCTK_Cmplx8Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER2(x) ((x) * (x)) */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) scalar = CCTK_Cmplx16Mul(scalar,scalar); scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx16Mul(scalar,scalar); scalar = CCTK_Cmplx16Mul(scalar,scalar); Norm4 = CCTK_Cmplx16Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER2(x) ((x) * (x)) */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #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(Norm4, scalar) scalar = CCTK_Cmplx32Mul(scalar,scalar); scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_Cmplx32Mul(scalar,scalar); scalar = CCTK_Cmplx32Mul(scalar,scalar); Norm4 = CCTK_Cmplx32Add( Norm4, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #ifdef POWER4 */ +/* #undef POWER4 */ +/* #endif */ +/* #ifdef POWER2 */ +/* #undef POWER2 */ +/* #endif */ +/* #define POWER2(x) ((x) * (x)) */ +/* #define POWER4(x) ((x) * (x) * (x) * (x)) */ + +/* #ifdef CCTK_REAL_PRECISION_4 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im))); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Norm4, scalar) Norm4 = Norm4 + POWER4(scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) Norm4 = Norm4 + POWER4(scalar*weight); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ +/* #endif */ + #ifdef __cplusplus } diff --git a/src/NormInfFunctions.c b/src/NormInfFunctions.c index 2897c96..ff4b484 100644 --- a/src/NormInfFunctions.c +++ b/src/NormInfFunctions.c @@ -96,96 +96,250 @@ int LocalReduce_NormInf_BYTE(int i, int weight_on, const void * const weight, CC ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} -#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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) +int LocalReduce_NormInf_INT(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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)) + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL @@ -207,130 +361,286 @@ int LocalReduce_NormInf_BYTE(int i, int weight_on, const void * const weight, CC #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); return 0; } -int LocalReduce_NormInf_INT(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef HAVE_CCTK_INT1 +int LocalReduce_NormInf_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -365,50 +675,294 @@ int LocalReduce_NormInf_INT(int i, int weight_on, const void * const weight, CCT { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; - #ifdef HAVE_CCTK_INT1 + #ifdef HAVE_CCTK_INT11 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_INT2 + #ifdef HAVE_CCTK_INT12 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_INT4 + #ifdef HAVE_CCTK_INT14 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_INT8 + #ifdef HAVE_CCTK_INT18 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} +#endif + +#ifdef HAVE_CCTK_INT2 +int LocalReduce_NormInf_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; + + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; + #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL @@ -423,3229 +977,310 @@ int LocalReduce_NormInf_INT(int i, int weight_on, const void * const weight, CCT #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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} - -#ifdef HAVE_CCTK_INT1 -int LocalReduce_NormInf_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT11 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT12 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT14 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT18 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_INT2 -int LocalReduce_NormInf_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT21 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT22 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT24 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT28 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_INT4 -int LocalReduce_NormInf_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_INT8 -int LocalReduce_NormInf_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -int LocalReduce_NormInf_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} - -#ifdef HAVE_CCTK_REAL4 -int LocalReduce_NormInf_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_REAL8 -int LocalReduce_NormInf_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -#ifdef HAVE_CCTK_REAL16 -int LocalReduce_NormInf_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} -#endif - -int LocalReduce_NormInf_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); -#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); -#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); -#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); -#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); -#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - Util_TableSetInt(param_table_handle, num_points, "num_points"); - Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); - return 0; -} - - -#ifdef HAVE_CCTK_COMPLEX8 -int LocalReduce_NormInf_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); - -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); -#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; + inval = (out_type) typed_vdata[sum_indices]; +#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); +#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); +#define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) switch (output_number_type_codes[i]) { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; - #ifdef HAVE_CCTK_INT1 + #ifdef HAVE_CCTK_INT21 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_INT2 + #ifdef HAVE_CCTK_INT22 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_INT4 + #ifdef HAVE_CCTK_INT24 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_INT8 + #ifdef HAVE_CCTK_INT28 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); - -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); -#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); -#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - + ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} #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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 +#ifdef HAVE_CCTK_INT4 +int LocalReduce_NormInf_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); -#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef ABS #undef ABS #endif @@ -3655,41 +1290,287 @@ int LocalReduce_NormInf_COMPLEX8(int i, int weight_on, const void * const weight #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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -3697,8 +1578,8 @@ int LocalReduce_NormInf_COMPLEX8(int i, int weight_on, const void * const weight } #endif -#ifdef HAVE_CCTK_COMPLEX16 -int LocalReduce_NormInf_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef HAVE_CCTK_INT8 +int LocalReduce_NormInf_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -3712,21 +1593,18 @@ int LocalReduce_NormInf_COMPLEX16(int i, int weight_on, const void * const weigh #undef WEIGHTED_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_Cmplx16Abs(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_Cmplx16Abs(typed_vdata[sum_indices])); +#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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); #define REDUCTION_INITIAL(num) num = 0; @@ -3736,103 +1614,298 @@ int LocalReduce_NormInf_COMPLEX16(int i, int weight_on, const void * const weigh { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} #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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 +int LocalReduce_NormInf_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); -#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef ABS #undef ABS #endif @@ -3842,98 +1915,309 @@ int LocalReduce_NormInf_COMPLEX16(int i, int weight_on, const void * const weigh #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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} -#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 +#ifdef HAVE_CCTK_REAL4 +int LocalReduce_NormInf_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); -#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef ABS #undef ABS #endif @@ -3943,41 +2227,287 @@ int LocalReduce_NormInf_COMPLEX16(int i, int weight_on, const void * const weigh #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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -3985,8 +2515,8 @@ int LocalReduce_NormInf_COMPLEX16(int i, int weight_on, const void * const weigh } #endif -#ifdef HAVE_CCTK_COMPLEX32 -int LocalReduce_NormInf_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef HAVE_CCTK_REAL8 +int LocalReduce_NormInf_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -4000,11 +2530,18 @@ int LocalReduce_NormInf_COMPLEX32(int i, int weight_on, const void * const weigh #undef WEIGHTED_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)) -#undef REDUCTION_PREOP_CAST #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); #define REDUCTION_INITIAL(num) num = 0; @@ -4014,103 +2551,300 @@ int LocalReduce_NormInf_COMPLEX32(int i, int weight_on, const void * const weigh { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + Util_TableSetInt(param_table_handle, num_points, "num_points"); + Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); + return 0; +} #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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 +#ifdef HAVE_CCTK_REAL16 +int LocalReduce_NormInf_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); -#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL #undef EXTRA_STEP +#undef REDUCTION_PREOP_CAST #ifdef ABS #undef ABS #endif @@ -4120,142 +2854,287 @@ int LocalReduce_NormInf_COMPLEX32(int i, int weight_on, const void * const weigh #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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 - + inval = (out_type) typed_vdata[sum_indices]; #define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); -#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); -#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight)); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } Util_TableSetInt(param_table_handle, num_points, "num_points"); Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); @@ -4263,6 +3142,1127 @@ int LocalReduce_NormInf_COMPLEX32(int i, int weight_on, const void * const weigh } #endif +/* int LocalReduce_NormInf_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); */ +/* #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); */ +/* #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); */ +/* #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); */ +/* #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); */ +/* #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ + + +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* int LocalReduce_NormInf_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); */ + +/* #define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); */ +/* #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL4) (CCTK_Cmplx8Abs(typed_vdata[sum_indices])); */ + +/* #define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); */ +/* #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); */ +/* #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); */ +/* #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); */ +/* #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ +/* #endif */ + +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* int LocalReduce_NormInf_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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_Cmplx16Abs(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_Cmplx16Abs(typed_vdata[sum_indices])); */ +/* #endif */ + +/* #define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); */ +/* #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); */ +/* #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); */ +/* #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); */ +/* #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); */ +/* #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ +/* #endif */ + +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* int LocalReduce_NormInf_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices])); */ + +/* #define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX(NormInf , ABS(scalar)); */ +/* #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); */ +/* #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); */ +/* #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); */ +/* #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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 = MAX(NormInf , ABS(scalar)); */ +/* #define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight) NormInf = MAX(NormInf , ABS(scalar*weight)); */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* Util_TableSetInt(param_table_handle, num_points, "num_points"); */ +/* Util_TableSetReal(param_table_handle, weight_sum, "weight_sum"); */ +/* return 0; */ +/* } */ +/* #endif */ + #ifdef __cplusplus } diff --git a/src/ReductionAvg.c b/src/ReductionAvg.c index 0cd1399..b51d774 100644 --- a/src/ReductionAvg.c +++ b/src/ReductionAvg.c @@ -288,24 +288,24 @@ static int ReductionAvg (int N_dims, int operator_handle, LocalReduce_Avg_REAL16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); break; #endif - case CCTK_VARIABLE_COMPLEX: - LocalReduce_Avg_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: - LocalReduce_Avg_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: - LocalReduce_Avg_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: - LocalReduce_Avg_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif + /* case CCTK_VARIABLE_COMPLEX: */ + /* LocalReduce_Avg_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* case CCTK_VARIABLE_COMPLEX8: */ + /* LocalReduce_Avg_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* case CCTK_VARIABLE_COMPLEX16: */ + /* LocalReduce_Avg_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* case CCTK_VARIABLE_COMPLEX32: */ + /* LocalReduce_Avg_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ } } @@ -377,28 +377,28 @@ static int ReductionAvg (int N_dims, int operator_handle, *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / weight_sum; break; #endif - case CCTK_VARIABLE_COMPLEX: - (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / weight_sum; - (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / weight_sum; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / weight_sum; - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / weight_sum; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / weight_sum; - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / weight_sum; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / weight_sum; - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / weight_sum; - break; - #endif + /* case CCTK_VARIABLE_COMPLEX: */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / weight_sum; */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / weight_sum; */ + /* break; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* case CCTK_VARIABLE_COMPLEX8: */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / weight_sum; */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / weight_sum; */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* case CCTK_VARIABLE_COMPLEX16: */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / weight_sum; */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / weight_sum; */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* case CCTK_VARIABLE_COMPLEX32: */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / weight_sum; */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / weight_sum; */ + /* break; */ + /* #endif */ } } } @@ -459,28 +459,28 @@ static int ReductionAvg (int N_dims, int operator_handle, *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; break; #endif - case CCTK_VARIABLE_COMPLEX: - (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; - break; - #endif + /* case CCTK_VARIABLE_COMPLEX: */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; */ + /* break; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* case CCTK_VARIABLE_COMPLEX8: */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* case CCTK_VARIABLE_COMPLEX16: */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points; */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* case CCTK_VARIABLE_COMPLEX32: */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; */ + /* break; */ + /* #endif */ } } } diff --git a/src/ReductionCount.c b/src/ReductionCount.c index 0eb0dda..e9e74b6 100644 --- a/src/ReductionCount.c +++ b/src/ReductionCount.c @@ -287,24 +287,24 @@ static int ReductionCount (int N_dims, int operator_handle, LocalReduce_Count_REAL16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); break; #endif - case CCTK_VARIABLE_COMPLEX: - LocalReduce_Count_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: - LocalReduce_Count_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: - LocalReduce_Count_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: - LocalReduce_Count_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif + /* case CCTK_VARIABLE_COMPLEX: */ + /* LocalReduce_Count_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* case CCTK_VARIABLE_COMPLEX8: */ + /* LocalReduce_Count_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* case CCTK_VARIABLE_COMPLEX16: */ + /* LocalReduce_Count_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* case CCTK_VARIABLE_COMPLEX32: */ + /* LocalReduce_Count_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ } } diff --git a/src/ReductionMax.c b/src/ReductionMax.c index 34dc2d7..b36b516 100644 --- a/src/ReductionMax.c +++ b/src/ReductionMax.c @@ -279,24 +279,24 @@ static int ReductionMax (int N_dims, int operator_handle, LocalReduce_Max_REAL16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); break; #endif - case CCTK_VARIABLE_COMPLEX: - LocalReduce_Max_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: - LocalReduce_Max_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: - LocalReduce_Max_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: - LocalReduce_Max_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif + /* case CCTK_VARIABLE_COMPLEX: */ + /* LocalReduce_Max_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* case CCTK_VARIABLE_COMPLEX8: */ + /* LocalReduce_Max_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* case CCTK_VARIABLE_COMPLEX16: */ + /* LocalReduce_Max_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* case CCTK_VARIABLE_COMPLEX32: */ + /* LocalReduce_Max_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ } } diff --git a/src/ReductionMin.c b/src/ReductionMin.c index 94965a3..0f1f192 100644 --- a/src/ReductionMin.c +++ b/src/ReductionMin.c @@ -281,24 +281,24 @@ static int ReductionMin (int N_dims, int operator_handle, num_points = LocalReduce_Min_REAL16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); break; #endif - case CCTK_VARIABLE_COMPLEX: - num_points = LocalReduce_Min_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: - num_points = LocalReduce_Min_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: - num_points = LocalReduce_Min_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: - num_points = LocalReduce_Min_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif + /* case CCTK_VARIABLE_COMPLEX: */ + /* num_points = LocalReduce_Min_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* case CCTK_VARIABLE_COMPLEX8: */ + /* num_points = LocalReduce_Min_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* case CCTK_VARIABLE_COMPLEX16: */ + /* num_points = LocalReduce_Min_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* case CCTK_VARIABLE_COMPLEX32: */ + /* num_points = LocalReduce_Min_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ } } diff --git a/src/ReductionNorm1.c b/src/ReductionNorm1.c index 675d2c9..ca4c109 100644 --- a/src/ReductionNorm1.c +++ b/src/ReductionNorm1.c @@ -292,24 +292,24 @@ static int ReductionL1 (int N_dims, int operator_handle, LocalReduce_Norm1_REAL16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); break; #endif - case CCTK_VARIABLE_COMPLEX: - LocalReduce_Norm1_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: - LocalReduce_Norm1_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: - LocalReduce_Norm1_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: - LocalReduce_Norm1_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif + /* case CCTK_VARIABLE_COMPLEX: */ + /* LocalReduce_Norm1_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* case CCTK_VARIABLE_COMPLEX8: */ + /* LocalReduce_Norm1_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* case CCTK_VARIABLE_COMPLEX16: */ + /* LocalReduce_Norm1_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* case CCTK_VARIABLE_COMPLEX32: */ + /* LocalReduce_Norm1_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ } } @@ -381,28 +381,28 @@ static int ReductionL1 (int N_dims, int operator_handle, *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / weight_sum; break; #endif - case CCTK_VARIABLE_COMPLEX: - (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / weight_sum; - (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / weight_sum; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / weight_sum; - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / weight_sum; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / weight_sum; - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / weight_sum; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / weight_sum; - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / weight_sum; - break; - #endif + /* case CCTK_VARIABLE_COMPLEX: */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / weight_sum; */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / weight_sum; */ + /* break; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* case CCTK_VARIABLE_COMPLEX8: */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / weight_sum; */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / weight_sum; */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* case CCTK_VARIABLE_COMPLEX16: */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / weight_sum; */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / weight_sum; */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* case CCTK_VARIABLE_COMPLEX32: */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / weight_sum; */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / weight_sum; */ + /* break; */ + /* #endif */ } } } @@ -463,28 +463,28 @@ static int ReductionL1 (int N_dims, int operator_handle, *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; break; #endif - case CCTK_VARIABLE_COMPLEX: - (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; - break; - #endif + /* case CCTK_VARIABLE_COMPLEX: */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; */ + /* break; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* case CCTK_VARIABLE_COMPLEX8: */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* case CCTK_VARIABLE_COMPLEX16: */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points; */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* case CCTK_VARIABLE_COMPLEX32: */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; */ + /* break; */ + /* #endif */ } } } diff --git a/src/ReductionNorm2.c b/src/ReductionNorm2.c index 0e25b00..59200fa 100644 --- a/src/ReductionNorm2.c +++ b/src/ReductionNorm2.c @@ -158,16 +158,16 @@ static int ReductionL2 (int N_dims, int operator_handle, CCTK_REAL weight_sum; /* temporary complex variables*/ - CCTK_COMPLEX cmplx_tmp; - #ifdef HAVE_CCTK_COMPLEX8 - CCTK_COMPLEX8 cmplx_tmp8; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - CCTK_COMPLEX16 cmplx_tmp16; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - CCTK_COMPLEX32 cmplx_tmp32; - #endif + /* CCTK_COMPLEX cmplx_tmp; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* CCTK_COMPLEX8 cmplx_tmp8; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* CCTK_COMPLEX16 cmplx_tmp16; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* CCTK_COMPLEX32 cmplx_tmp32; */ + /* #endif */ /* prevent warnings for unused vars */ (void)(operator_handle + 0); @@ -306,24 +306,24 @@ static int ReductionL2 (int N_dims, int operator_handle, num_points = LocalReduce_Norm2_REAL16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); break; #endif - case CCTK_VARIABLE_COMPLEX: - num_points = LocalReduce_Norm2_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: - num_points = LocalReduce_Norm2_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: - num_points = LocalReduce_Norm2_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: - num_points = LocalReduce_Norm2_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif + /* case CCTK_VARIABLE_COMPLEX: */ + /* num_points = LocalReduce_Norm2_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* case CCTK_VARIABLE_COMPLEX8: */ + /* num_points = LocalReduce_Norm2_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* case CCTK_VARIABLE_COMPLEX16: */ + /* num_points = LocalReduce_Norm2_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* case CCTK_VARIABLE_COMPLEX32: */ + /* num_points = LocalReduce_Norm2_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ } } @@ -406,48 +406,48 @@ static int ReductionL2 (int N_dims, int operator_handle, *( (CCTK_REAL16 *) output_numbers[i]) = sqrt(*( (CCTK_REAL16 *) output_numbers[i])); break; #endif - case CCTK_VARIABLE_COMPLEX: - (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / weight_sum; - (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / weight_sum; - cmplx_tmp.Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re; - cmplx_tmp.Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0); - (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re; - (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / weight_sum; - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / weight_sum; - cmplx_tmp8.Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re; - cmplx_tmp8.Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0); - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = cmplx_tmp8.Re; - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / weight_sum; - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / weight_sum; - cmplx_tmp16.Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re; - cmplx_tmp16.Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0); - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = cmplx_tmp16.Re; - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / weight_sum; - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / weight_sum; - cmplx_tmp32.Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re; - cmplx_tmp32.Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0); - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = cmplx_tmp32.Re; - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = cmplx_tmp32.Im; - break; - #endif + /* case CCTK_VARIABLE_COMPLEX: */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / weight_sum; */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / weight_sum; */ + /* cmplx_tmp.Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re; */ + /* cmplx_tmp.Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0); */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re; */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im; */ + /* break; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* case CCTK_VARIABLE_COMPLEX8: */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / weight_sum; */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / weight_sum; */ + /* cmplx_tmp8.Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re; */ + /* cmplx_tmp8.Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0); */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = cmplx_tmp8.Re; */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im; */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* case CCTK_VARIABLE_COMPLEX16: */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / weight_sum; */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / weight_sum; */ + /* cmplx_tmp16.Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re; */ + /* cmplx_tmp16.Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0); */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = cmplx_tmp16.Re; */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im; */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* case CCTK_VARIABLE_COMPLEX32: */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / weight_sum; */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / weight_sum; */ + /* cmplx_tmp32.Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re; */ + /* cmplx_tmp32.Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0); */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = cmplx_tmp32.Re; */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = cmplx_tmp32.Im; */ + /* break; */ + /* #endif */ } } } @@ -518,48 +518,48 @@ static int ReductionL2 (int N_dims, int operator_handle, *( (CCTK_REAL16 *) output_numbers[i]) = sqrt(*( (CCTK_REAL16 *) output_numbers[i])); break; #endif - case CCTK_VARIABLE_COMPLEX: - (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; - cmplx_tmp.Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re; - cmplx_tmp.Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0); - (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re; - (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; - cmplx_tmp8.Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re; - cmplx_tmp8.Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0); - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = cmplx_tmp8.Re; - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points; - cmplx_tmp16.Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re; - cmplx_tmp16.Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0); - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = cmplx_tmp16.Re; - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; - cmplx_tmp32.Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re; - cmplx_tmp32.Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0); - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = cmplx_tmp32.Re; - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = cmplx_tmp32.Im; - break; - #endif + /* case CCTK_VARIABLE_COMPLEX: */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; */ + /* cmplx_tmp.Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re; */ + /* cmplx_tmp.Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0); */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re; */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im; */ + /* break; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* case CCTK_VARIABLE_COMPLEX8: */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; */ + /* cmplx_tmp8.Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re; */ + /* cmplx_tmp8.Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0); */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = cmplx_tmp8.Re; */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im; */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* case CCTK_VARIABLE_COMPLEX16: */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points; */ + /* cmplx_tmp16.Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re; */ + /* cmplx_tmp16.Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0); */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = cmplx_tmp16.Re; */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im; */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* case CCTK_VARIABLE_COMPLEX32: */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; */ + /* cmplx_tmp32.Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re; */ + /* cmplx_tmp32.Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0); */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = cmplx_tmp32.Re; */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = cmplx_tmp32.Im; */ + /* break; */ + /* #endif */ } } } diff --git a/src/ReductionNorm3.c b/src/ReductionNorm3.c index c45b8b6..c7b55be 100644 --- a/src/ReductionNorm3.c +++ b/src/ReductionNorm3.c @@ -158,16 +158,16 @@ static int ReductionL3 (int N_dims, int operator_handle, CCTK_REAL weight_sum; /* temporary complex variables*/ - CCTK_COMPLEX cmplx_tmp; - #ifdef HAVE_CCTK_COMPLEX8 - CCTK_COMPLEX8 cmplx_tmp8; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - CCTK_COMPLEX16 cmplx_tmp16; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - CCTK_COMPLEX32 cmplx_tmp32; - #endif + /* CCTK_COMPLEX cmplx_tmp; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* CCTK_COMPLEX8 cmplx_tmp8; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* CCTK_COMPLEX16 cmplx_tmp16; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* CCTK_COMPLEX32 cmplx_tmp32; */ + /* #endif */ /* prevent warnings for unused vars */ (void)(operator_handle + 0); @@ -303,24 +303,24 @@ static int ReductionL3 (int N_dims, int operator_handle, LocalReduce_Norm3_REAL16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); break; #endif - case CCTK_VARIABLE_COMPLEX: - LocalReduce_Norm3_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: - LocalReduce_Norm3_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: - LocalReduce_Norm3_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: - LocalReduce_Norm3_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif + /* case CCTK_VARIABLE_COMPLEX: */ + /* LocalReduce_Norm3_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* case CCTK_VARIABLE_COMPLEX8: */ + /* LocalReduce_Norm3_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* case CCTK_VARIABLE_COMPLEX16: */ + /* LocalReduce_Norm3_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* case CCTK_VARIABLE_COMPLEX32: */ + /* LocalReduce_Norm3_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ } } @@ -403,48 +403,48 @@ static int ReductionL3 (int N_dims, int operator_handle, *( (CCTK_REAL16 *) output_numbers[i]) = pow(*( (CCTK_REAL16 *) output_numbers[i]), 1.0/3.0); break; #endif - case CCTK_VARIABLE_COMPLEX: - (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; - cmplx_tmp.Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re; - cmplx_tmp.Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0); - (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re; - (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; - cmplx_tmp8.Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re; - cmplx_tmp8.Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0); - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = cmplx_tmp8.Re; - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points; - cmplx_tmp16.Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re; - cmplx_tmp16.Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0); - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = cmplx_tmp16.Re; - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; - cmplx_tmp32.Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re; - cmplx_tmp32.Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0); - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = cmplx_tmp32.Re; - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = cmplx_tmp32.Im; - break; - #endif + /* case CCTK_VARIABLE_COMPLEX: */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; */ + /* cmplx_tmp.Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re; */ + /* cmplx_tmp.Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0); */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re; */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im; */ + /* break; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* case CCTK_VARIABLE_COMPLEX8: */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; */ + /* cmplx_tmp8.Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re; */ + /* cmplx_tmp8.Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0); */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = cmplx_tmp8.Re; */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im; */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* case CCTK_VARIABLE_COMPLEX16: */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points; */ + /* cmplx_tmp16.Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re; */ + /* cmplx_tmp16.Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0); */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = cmplx_tmp16.Re; */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im; */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* case CCTK_VARIABLE_COMPLEX32: */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; */ + /* cmplx_tmp32.Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re; */ + /* cmplx_tmp32.Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0); */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = cmplx_tmp32.Re; */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = cmplx_tmp32.Im; */ + /* break; */ + /* #endif */ } } } @@ -515,48 +515,48 @@ static int ReductionL3 (int N_dims, int operator_handle, *( (CCTK_REAL16 *) output_numbers[i]) = pow(*( (CCTK_REAL16 *) output_numbers[i]), 1.0/3.0); break; #endif - case CCTK_VARIABLE_COMPLEX: - (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; - cmplx_tmp.Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re; - cmplx_tmp.Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0); - (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re; - (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; - cmplx_tmp8.Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re; - cmplx_tmp8.Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0); - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = cmplx_tmp8.Re; - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points; - cmplx_tmp16.Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re; - cmplx_tmp16.Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0); - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = cmplx_tmp16.Re; - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; - cmplx_tmp32.Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re; - cmplx_tmp32.Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0); - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = cmplx_tmp32.Re; - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = cmplx_tmp32.Im; - break; - #endif + /* case CCTK_VARIABLE_COMPLEX: */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; */ + /* cmplx_tmp.Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re; */ + /* cmplx_tmp.Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0); */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re; */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im; */ + /* break; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* case CCTK_VARIABLE_COMPLEX8: */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; */ + /* cmplx_tmp8.Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re; */ + /* cmplx_tmp8.Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0); */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = cmplx_tmp8.Re; */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im; */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* case CCTK_VARIABLE_COMPLEX16: */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points; */ + /* cmplx_tmp16.Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re; */ + /* cmplx_tmp16.Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0); */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = cmplx_tmp16.Re; */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im; */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* case CCTK_VARIABLE_COMPLEX32: */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; */ + /* cmplx_tmp32.Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re; */ + /* cmplx_tmp32.Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0); */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = cmplx_tmp32.Re; */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = cmplx_tmp32.Im; */ + /* break; */ + /* #endif */ } } } diff --git a/src/ReductionNorm4.c b/src/ReductionNorm4.c index 6c6fb6f..afe939a 100644 --- a/src/ReductionNorm4.c +++ b/src/ReductionNorm4.c @@ -158,16 +158,16 @@ static int ReductionL4 (int N_dims, int operator_handle, CCTK_REAL weight_sum; /* temporary complex variables*/ - CCTK_COMPLEX cmplx_tmp; - #ifdef HAVE_CCTK_COMPLEX8 - CCTK_COMPLEX8 cmplx_tmp8; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - CCTK_COMPLEX16 cmplx_tmp16; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - CCTK_COMPLEX32 cmplx_tmp32; - #endif + /* CCTK_COMPLEX cmplx_tmp; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* CCTK_COMPLEX8 cmplx_tmp8; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* CCTK_COMPLEX16 cmplx_tmp16; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* CCTK_COMPLEX32 cmplx_tmp32; */ + /* #endif */ /* prevent warnings for unused vars */ (void)(operator_handle + 0); @@ -303,24 +303,24 @@ static int ReductionL4 (int N_dims, int operator_handle, LocalReduce_Norm4_REAL16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); break; #endif - case CCTK_VARIABLE_COMPLEX: - LocalReduce_Norm4_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: - LocalReduce_Norm4_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: - LocalReduce_Norm4_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: - LocalReduce_Norm4_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif + /* case CCTK_VARIABLE_COMPLEX: */ + /* LocalReduce_Norm4_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* case CCTK_VARIABLE_COMPLEX8: */ + /* LocalReduce_Norm4_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* case CCTK_VARIABLE_COMPLEX16: */ + /* LocalReduce_Norm4_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* case CCTK_VARIABLE_COMPLEX32: */ + /* LocalReduce_Norm4_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ } } @@ -403,48 +403,48 @@ static int ReductionL4 (int N_dims, int operator_handle, *( (CCTK_REAL16 *) output_numbers[i]) = pow(*( (CCTK_REAL16 *) output_numbers[i]), 1.0/4.0); break; #endif - case CCTK_VARIABLE_COMPLEX: - (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / weight_sum; - (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / weight_sum; - cmplx_tmp.Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re; - cmplx_tmp.Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0); - (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re; - (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / weight_sum; - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / weight_sum; - cmplx_tmp8.Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re; - cmplx_tmp8.Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0); - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = cmplx_tmp8.Re; - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / weight_sum; - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / weight_sum; - cmplx_tmp16.Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re; - cmplx_tmp16.Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0); - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = cmplx_tmp16.Re; - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / weight_sum; - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / weight_sum; - cmplx_tmp32.Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re; - cmplx_tmp32.Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0); - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = cmplx_tmp32.Re; - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = cmplx_tmp32.Im; - break; - #endif + /* case CCTK_VARIABLE_COMPLEX: */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / weight_sum; */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / weight_sum; */ + /* cmplx_tmp.Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re; */ + /* cmplx_tmp.Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0); */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re; */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im; */ + /* break; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* case CCTK_VARIABLE_COMPLEX8: */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / weight_sum; */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / weight_sum; */ + /* cmplx_tmp8.Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re; */ + /* cmplx_tmp8.Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0); */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = cmplx_tmp8.Re; */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im; */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* case CCTK_VARIABLE_COMPLEX16: */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / weight_sum; */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / weight_sum; */ + /* cmplx_tmp16.Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re; */ + /* cmplx_tmp16.Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0); */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = cmplx_tmp16.Re; */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im; */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* case CCTK_VARIABLE_COMPLEX32: */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / weight_sum; */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / weight_sum; */ + /* cmplx_tmp32.Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re; */ + /* cmplx_tmp32.Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0); */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = cmplx_tmp32.Re; */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = cmplx_tmp32.Im; */ + /* break; */ + /* #endif */ } } } @@ -515,48 +515,48 @@ static int ReductionL4 (int N_dims, int operator_handle, *( (CCTK_REAL16 *) output_numbers[i]) = pow(*( (CCTK_REAL16 *) output_numbers[i]), 1.0/4.0); break; #endif - case CCTK_VARIABLE_COMPLEX: - (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; - cmplx_tmp.Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re; - cmplx_tmp.Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0); - (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re; - (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; - cmplx_tmp8.Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re; - cmplx_tmp8.Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0); - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = cmplx_tmp8.Re; - (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points; - cmplx_tmp16.Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re; - cmplx_tmp16.Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0); - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = cmplx_tmp16.Re; - (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im; - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; - cmplx_tmp32.Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re; - cmplx_tmp32.Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im; - cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0); - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = cmplx_tmp32.Re; - (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = cmplx_tmp32.Im; - break; - #endif + /* case CCTK_VARIABLE_COMPLEX: */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; */ + /* cmplx_tmp.Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re; */ + /* cmplx_tmp.Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0); */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re; */ + /* (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im; */ + /* break; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* case CCTK_VARIABLE_COMPLEX8: */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; */ + /* cmplx_tmp8.Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re; */ + /* cmplx_tmp8.Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0); */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = cmplx_tmp8.Re; */ + /* (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im; */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* case CCTK_VARIABLE_COMPLEX16: */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points; */ + /* cmplx_tmp16.Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re; */ + /* cmplx_tmp16.Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0); */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = cmplx_tmp16.Re; */ + /* (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im; */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* case CCTK_VARIABLE_COMPLEX32: */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; */ + /* cmplx_tmp32.Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re; */ + /* cmplx_tmp32.Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im; */ + /* cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0); */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = cmplx_tmp32.Re; */ + /* (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = cmplx_tmp32.Im; */ + /* break; */ + /* #endif */ } } } diff --git a/src/ReductionNormInf.c b/src/ReductionNormInf.c index 060d3b0..6471320 100644 --- a/src/ReductionNormInf.c +++ b/src/ReductionNormInf.c @@ -297,24 +297,24 @@ static int ReductionLInf (int N_dims, int operator_handle, LocalReduce_NormInf_REAL16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); break; #endif - case CCTK_VARIABLE_COMPLEX: - LocalReduce_NormInf_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: - LocalReduce_NormInf_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: - LocalReduce_NormInf_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: - LocalReduce_NormInf_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif + /* case CCTK_VARIABLE_COMPLEX: */ + /* LocalReduce_NormInf_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* case CCTK_VARIABLE_COMPLEX8: */ + /* LocalReduce_NormInf_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* case CCTK_VARIABLE_COMPLEX16: */ + /* LocalReduce_NormInf_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* case CCTK_VARIABLE_COMPLEX32: */ + /* LocalReduce_NormInf_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ } } diff --git a/src/ReductionSum.c b/src/ReductionSum.c index 61c96a2..5c5d7d9 100644 --- a/src/ReductionSum.c +++ b/src/ReductionSum.c @@ -290,24 +290,24 @@ static int ReductionSum (int N_dims, int operator_handle, num_points = LocalReduce_Sum_REAL16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); break; #endif - case CCTK_VARIABLE_COMPLEX: - num_points = LocalReduce_Sum_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: - num_points = LocalReduce_Sum_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: - num_points = LocalReduce_Sum_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: - num_points = LocalReduce_Sum_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); - break; - #endif + /* case CCTK_VARIABLE_COMPLEX: */ + /* num_points = LocalReduce_Sum_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #ifdef HAVE_CCTK_COMPLEX8 */ + /* case CCTK_VARIABLE_COMPLEX8: */ + /* num_points = LocalReduce_Sum_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX16 */ + /* case CCTK_VARIABLE_COMPLEX16: */ + /* num_points = LocalReduce_Sum_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ + /* #ifdef HAVE_CCTK_COMPLEX32 */ + /* case CCTK_VARIABLE_COMPLEX32: */ + /* num_points = LocalReduce_Sum_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim, N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle); */ + /* break; */ + /* #endif */ } } diff --git a/src/SumFunctions.c b/src/SumFunctions.c index 588b595..193105b 100644 --- a/src/SumFunctions.c +++ b/src/SumFunctions.c @@ -88,170 +88,170 @@ int LocalReduce_Sum_BYTE(int i, int weight_on, const void * const weight, CCTK_I ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } return num_points; } @@ -326,167 +326,167 @@ int LocalReduce_Sum_INT(int i, int weight_on, const void * const weight, CCTK_IN ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } return num_points; } @@ -562,184 +562,184 @@ int LocalReduce_Sum_INT1(int i, int weight_on, const void * const weight, CCTK_I ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + return num_points; +} +#endif -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) +#ifdef HAVE_CCTK_INT2 +int LocalReduce_Sum_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} -#endif - -#ifdef HAVE_CCTK_INT2 -int LocalReduce_Sum_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -801,169 +801,169 @@ int LocalReduce_Sum_INT2(int i, int weight_on, const void * const weight, CCTK_I ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } return num_points; } @@ -1040,71 +1040,185 @@ int LocalReduce_Sum_INT4(int i, int weight_on, const void * const weight, CCTK_I ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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]; +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + return num_points; +} #endif -#define REDUCTION_OPERATION(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) +#ifdef HAVE_CCTK_INT8 +int LocalReduce_Sum_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL @@ -1118,98 +1232,222 @@ int LocalReduce_Sum_INT4(int i, int weight_on, const void * const weight, CCTK_I #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } return num_points; } #endif -#ifdef HAVE_CCTK_INT8 -int LocalReduce_Sum_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +int LocalReduce_Sum_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -1236,114 +1474,227 @@ int LocalReduce_Sum_INT8(int i, int weight_on, const void * const weight, CCTK_I { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + return num_points; +} -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) +#ifdef HAVE_CCTK_REAL4 +int LocalReduce_Sum_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +{ + int iter = 0; + int sum_indices = 0; + int flag, product, j, k; - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST + /* Weight variables */ + CCTK_REAL weight_sum = 0.0; + CCTK_REAL weight_value = 1.0; -#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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION #undef REDUCTION_INITIAL @@ -1357,97 +1708,223 @@ int LocalReduce_Sum_INT8(int i, int weight_on, const void * const weight, CCTK_I #define REDUCTION_INITIAL(num) num = 0; #define EXTRA_STEP(a, b) + switch (output_number_type_codes[i]) + { + /* out values type switches*/ + case CCTK_VARIABLE_BYTE: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + case CCTK_VARIABLE_INT: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - + #ifdef HAVE_CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + #ifdef HAVE_CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + case CCTK_VARIABLE_REAL: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #ifdef HAVE_CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif + #ifdef HAVE_CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif + #ifdef HAVE_CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + break; + #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } return num_points; } #endif -int LocalReduce_Sum_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef HAVE_CCTK_REAL8 +int LocalReduce_Sum_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -1474,218 +1951,220 @@ int LocalReduce_Sum_REAL(int i, int weight_on, const void * const weight, CCTK_I { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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]; +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ + +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ + } + return num_points; +} #endif -#define REDUCTION_OPERATION(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} -#ifdef HAVE_CCTK_REAL4 -int LocalReduce_Sum_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) +#ifdef HAVE_CCTK_REAL16 +int LocalReduce_Sum_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) { int iter = 0; int sum_indices = 0; @@ -1712,1710 +2191,1231 @@ int LocalReduce_Sum_REAL4(int i, int weight_on, const void * const weight, CCTK_ { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) + ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) break; #endif +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ +/* #undef REDUCTION_PREOP_CAST */ + +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (out_type) typed_vdata[sum_indices]; */ +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ } return num_points; } #endif -#ifdef HAVE_CCTK_REAL8 -int LocalReduce_Sum_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; - -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} -#endif - -#ifdef HAVE_CCTK_REAL16 -int LocalReduce_Sum_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP -#undef REDUCTION_PREOP_CAST - -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (out_type) typed_vdata[sum_indices]; -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} -#endif - -int LocalReduce_Sum_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} - - -#ifdef HAVE_CCTK_COMPLEX8 -int LocalReduce_Sum_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} -#endif - -#ifdef HAVE_CCTK_COMPLEX16 -int LocalReduce_Sum_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} -#endif - -#ifdef HAVE_CCTK_COMPLEX32 -int LocalReduce_Sum_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) -{ - int iter = 0; - int sum_indices = 0; - int flag, product, j, k; - - /* Weight variables */ - CCTK_REAL weight_sum = 0.0; - CCTK_REAL weight_value = 1.0; - -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - switch (output_number_type_codes[i]) - { - /* out values type switches*/ - case CCTK_VARIABLE_BYTE: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - case CCTK_VARIABLE_INT: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_INT1 - case CCTK_VARIABLE_INT1: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT2 - case CCTK_VARIABLE_INT2: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT4 - case CCTK_VARIABLE_INT4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_INT8 - case CCTK_VARIABLE_INT8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_REAL: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #ifdef HAVE_CCTK_REAL4 - case CCTK_VARIABLE_REAL4: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL8 - case CCTK_VARIABLE_REAL8: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - #ifdef HAVE_CCTK_REAL16 - case CCTK_VARIABLE_REAL16: - ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) - break; - #endif - case CCTK_VARIABLE_COMPLEX: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #ifdef HAVE_CCTK_COMPLEX8 - case CCTK_VARIABLE_COMPLEX8: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX16 - case CCTK_VARIABLE_COMPLEX16: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - - break; - #endif - #ifdef HAVE_CCTK_COMPLEX32 - case CCTK_VARIABLE_COMPLEX32: -#undef REDUCTION_OPERATION -#undef WEIGHTED_REDUCTION_OPERATION -#undef REDUCTION_INITIAL -#undef EXTRA_STEP - -#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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); -#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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) -#undef REDUCTION_OPERATION -#undef WEIGHTED_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) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_8 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; -#elif CCTK_REAL_PRECISION_16 -#undef REDUCTION_PREOP_CAST -#define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ - inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; -#endif - -#define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; -#define REDUCTION_INITIAL(num) num = 0; -#define EXTRA_STEP(a, b) - break; - #endif - } - return num_points; -} -#endif +/* int LocalReduce_Sum_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* return num_points; */ +/* } */ + + +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* int LocalReduce_Sum_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* return num_points; */ +/* } */ +/* #endif */ + +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* int LocalReduce_Sum_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* return num_points; */ +/* } */ +/* #endif */ + +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* int LocalReduce_Sum_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, 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 param_table_handle) */ +/* { */ +/* int iter = 0; */ +/* int sum_indices = 0; */ +/* int flag, product, j, k; */ + +/* /\* Weight variables *\/ */ +/* CCTK_REAL weight_sum = 0.0; */ +/* CCTK_REAL weight_value = 1.0; */ + +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* switch (output_number_type_codes[i]) */ +/* { */ +/* /\* out values type switches*\/ */ +/* case CCTK_VARIABLE_BYTE: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* case CCTK_VARIABLE_INT: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_INT1 */ +/* case CCTK_VARIABLE_INT1: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT2 */ +/* case CCTK_VARIABLE_INT2: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT4 */ +/* case CCTK_VARIABLE_INT4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_INT8 */ +/* case CCTK_VARIABLE_INT8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_REAL: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #ifdef HAVE_CCTK_REAL4 */ +/* case CCTK_VARIABLE_REAL4: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL8 */ +/* case CCTK_VARIABLE_REAL8: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_REAL16 */ +/* case CCTK_VARIABLE_REAL16: */ +/* ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* break; */ +/* #endif */ +/* case CCTK_VARIABLE_COMPLEX: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Sum, scalar) Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #ifdef HAVE_CCTK_COMPLEX8 */ +/* case CCTK_VARIABLE_COMPLEX8: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx8Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX16 */ +/* case CCTK_VARIABLE_COMPLEX16: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx16Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ + +/* break; */ +/* #endif */ +/* #ifdef HAVE_CCTK_COMPLEX32 */ +/* case CCTK_VARIABLE_COMPLEX32: */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_REDUCTION_OPERATION */ +/* #undef REDUCTION_INITIAL */ +/* #undef EXTRA_STEP */ + +/* #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(Sum, scalar) Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_Cmplx32Add( Sum, scalar); */ +/* #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], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) */ +/* #undef REDUCTION_OPERATION */ +/* #undef WEIGHTED_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) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_8 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL8) typed_vdata[sum_indices].Re; */ +/* #elif CCTK_REAL_PRECISION_16 */ +/* #undef REDUCTION_PREOP_CAST */ +/* #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ */ +/* inval = (CCTK_REAL16) typed_vdata[sum_indices].Re; */ +/* #endif */ + +/* #define REDUCTION_OPERATION(Sum, scalar) Sum = Sum + scalar; */ +/* #define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) Sum = Sum + scalar*weight; */ +/* #define REDUCTION_INITIAL(num) num = 0; */ +/* #define EXTRA_STEP(a, b) */ +/* break; */ +/* #endif */ +/* } */ +/* return num_points; */ +/* } */ +/* #endif */ #ifdef __cplusplus -- cgit v1.2.3