From 6a6f2e17f2b8bd5e205a104526824972b945ce4c Mon Sep 17 00:00:00 2001 From: yye00 Date: Tue, 25 Oct 2005 20:30:16 +0000 Subject: This patch switches checking from #ifdef cctk_* to #ifdef have_cctk*, otherwise it contains minor changes here and there, code cleanup and such. Please confirm testglobal and testlocal reduce git-svn-id: http://svn.cactuscode.org/arrangements/CactusBase/LocalReduce/trunk@66 7daa882c-dc44-4453-834e-278d26b18e6a --- src/AvgFunctions.c | 458 ++++++++++++++++++++++---------------------- src/Avg_Functions.h | 20 +- src/CountFunctions.c | 302 ++++++++++++++--------------- src/Count_Functions.h | 20 +- src/MaxFunctions.c | 290 ++++++++++++++-------------- src/Max_Functions.h | 20 +- src/MinFunctions.c | 302 ++++++++++++++--------------- src/Min_Functions.h | 20 +- src/Norm1Functions.c | 360 +++++++++++++---------------------- src/Norm1_Functions.h | 20 +- src/Norm2Functions.c | 490 ++++++++++++++++++++++++------------------------ src/Norm2_Functions.h | 20 +- src/Norm3Functions.c | 470 +++++++++++++++++++++++----------------------- src/Norm3_Functions.h | 20 +- src/Norm4Functions.c | 470 +++++++++++++++++++++++----------------------- src/Norm4_Functions.h | 20 +- src/NormInfFunctions.c | 422 ++++++++++++++++++++--------------------- src/NormInf_Functions.h | 20 +- src/ReductionAvg.c | 60 +++--- src/ReductionCount.c | 20 +- src/ReductionMax.c | 20 +- src/ReductionMin.c | 20 +- src/ReductionNorm1.c | 60 +++--- src/ReductionNorm2.c | 66 +++---- src/ReductionNorm3.c | 66 +++---- src/ReductionNorm4.c | 66 +++---- src/ReductionNormInf.c | 60 +++--- src/ReductionSum.c | 20 +- src/SumFunctions.c | 470 +++++++++++++++++++++++----------------------- src/Sum_Functions.h | 20 +- 30 files changed, 2296 insertions(+), 2396 deletions(-) diff --git a/src/AvgFunctions.c b/src/AvgFunctions.c index d30dbe1..9d7a89a 100644 --- a/src/AvgFunctions.c +++ b/src/AvgFunctions.c @@ -51,22 +51,22 @@ int LocalReduce_Avg_BYTE(int i, int weight_on, const void * const weight, CCTK_I case CCTK_VARIABLE_INT: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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; @@ -74,17 +74,17 @@ int LocalReduce_Avg_BYTE(int i, int weight_on, const void * const weight, CCTK_I case CCTK_VARIABLE_REAL: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: 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; @@ -129,7 +129,7 @@ int LocalReduce_Avg_BYTE(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -150,8 +150,8 @@ int LocalReduce_Avg_BYTE(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd8( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd8( avg, scalar); +#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) @@ -170,7 +170,7 @@ int LocalReduce_Avg_BYTE(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -191,8 +191,8 @@ int LocalReduce_Avg_BYTE(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd16( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd16( avg, scalar); +#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) @@ -212,7 +212,7 @@ int LocalReduce_Avg_BYTE(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -233,8 +233,8 @@ int LocalReduce_Avg_BYTE(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd32( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd32( avg, scalar); +#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) @@ -292,22 +292,22 @@ int LocalReduce_Avg_INT(int i, int weight_on, const void * const weight, CCTK_IN 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -315,17 +315,17 @@ int LocalReduce_Avg_INT(int i, int weight_on, const void * const weight, CCTK_IN 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 CCTK_REAL4 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -369,7 +369,7 @@ int LocalReduce_Avg_INT(int i, int weight_on, const void * const weight, CCTK_IN #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -390,8 +390,8 @@ int LocalReduce_Avg_INT(int i, int weight_on, const void * const weight, CCTK_IN #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_CmplxAdd8( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd8( avg, scalar); +#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) @@ -410,7 +410,7 @@ int LocalReduce_Avg_INT(int i, int weight_on, const void * const weight, CCTK_IN break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -431,8 +431,8 @@ int LocalReduce_Avg_INT(int i, int weight_on, const void * const weight, CCTK_IN #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_CmplxAdd16( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd16( avg, scalar); +#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) @@ -451,7 +451,7 @@ int LocalReduce_Avg_INT(int i, int weight_on, const void * const weight, CCTK_IN break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -472,8 +472,8 @@ int LocalReduce_Avg_INT(int i, int weight_on, const void * const weight, CCTK_IN #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_CmplxAdd32( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd32( avg, scalar); +#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) @@ -530,22 +530,22 @@ int LocalReduce_Avg_INT1(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_INT12 + #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 CCTK_INT14 + #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 CCTK_INT18 + #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; @@ -553,17 +553,17 @@ int LocalReduce_Avg_INT1(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -607,7 +607,7 @@ int LocalReduce_Avg_INT1(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -628,8 +628,8 @@ int LocalReduce_Avg_INT1(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd8( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd8( avg, scalar); +#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) @@ -648,7 +648,7 @@ int LocalReduce_Avg_INT1(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -669,8 +669,8 @@ int LocalReduce_Avg_INT1(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd16( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd16( avg, scalar); +#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) @@ -690,7 +690,7 @@ int LocalReduce_Avg_INT1(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -711,8 +711,8 @@ int LocalReduce_Avg_INT1(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd32( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd32( avg, scalar); +#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) @@ -771,22 +771,22 @@ int LocalReduce_Avg_INT2(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_INT22 + #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 CCTK_INT24 + #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 CCTK_INT28 + #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; @@ -794,17 +794,17 @@ int LocalReduce_Avg_INT2(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -848,7 +848,7 @@ int LocalReduce_Avg_INT2(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -869,8 +869,8 @@ int LocalReduce_Avg_INT2(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd8( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd8( avg, scalar); +#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) @@ -889,7 +889,7 @@ int LocalReduce_Avg_INT2(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -910,8 +910,8 @@ int LocalReduce_Avg_INT2(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd16( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd16( avg, scalar); +#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) @@ -931,7 +931,7 @@ int LocalReduce_Avg_INT2(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -952,8 +952,8 @@ int LocalReduce_Avg_INT2(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd32( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd32( avg, scalar); +#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) @@ -1012,22 +1012,22 @@ int LocalReduce_Avg_INT4(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1035,17 +1035,17 @@ int LocalReduce_Avg_INT4(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1089,7 +1089,7 @@ int LocalReduce_Avg_INT4(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1110,8 +1110,8 @@ int LocalReduce_Avg_INT4(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd8( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd8( avg, scalar); +#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) @@ -1130,7 +1130,7 @@ int LocalReduce_Avg_INT4(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1151,8 +1151,8 @@ int LocalReduce_Avg_INT4(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd16( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd16( avg, scalar); +#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) @@ -1172,7 +1172,7 @@ int LocalReduce_Avg_INT4(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1193,8 +1193,8 @@ int LocalReduce_Avg_INT4(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd32( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd32( avg, scalar); +#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) @@ -1253,22 +1253,22 @@ int LocalReduce_Avg_INT8(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1276,17 +1276,17 @@ int LocalReduce_Avg_INT8(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1330,7 +1330,7 @@ int LocalReduce_Avg_INT8(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1351,8 +1351,8 @@ int LocalReduce_Avg_INT8(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd8( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd8( avg, scalar); +#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) @@ -1371,7 +1371,7 @@ int LocalReduce_Avg_INT8(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1392,8 +1392,8 @@ int LocalReduce_Avg_INT8(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd16( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd16( avg, scalar); +#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) @@ -1413,7 +1413,7 @@ int LocalReduce_Avg_INT8(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1434,8 +1434,8 @@ int LocalReduce_Avg_INT8(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd32( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd32( avg, scalar); +#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) @@ -1493,22 +1493,22 @@ int LocalReduce_Avg_REAL(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1516,17 +1516,17 @@ int LocalReduce_Avg_REAL(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1570,7 +1570,7 @@ int LocalReduce_Avg_REAL(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1591,8 +1591,8 @@ int LocalReduce_Avg_REAL(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd8( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd8( avg, scalar); +#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) @@ -1611,7 +1611,7 @@ int LocalReduce_Avg_REAL(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1632,8 +1632,8 @@ int LocalReduce_Avg_REAL(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd16( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd16( avg, scalar); +#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) @@ -1653,7 +1653,7 @@ int LocalReduce_Avg_REAL(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1674,8 +1674,8 @@ int LocalReduce_Avg_REAL(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd32( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd32( avg, scalar); +#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) @@ -1733,22 +1733,22 @@ int LocalReduce_Avg_REAL4(int i, int weight_on, const void * const weight, CCTK_ 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1756,17 +1756,17 @@ int LocalReduce_Avg_REAL4(int i, int weight_on, const void * const weight, CCTK_ 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1810,7 +1810,7 @@ int LocalReduce_Avg_REAL4(int i, int weight_on, const void * const weight, CCTK_ #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1831,8 +1831,8 @@ int LocalReduce_Avg_REAL4(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd8( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd8( avg, scalar); +#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) @@ -1851,7 +1851,7 @@ int LocalReduce_Avg_REAL4(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1872,8 +1872,8 @@ int LocalReduce_Avg_REAL4(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd16( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd16( avg, scalar); +#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) @@ -1893,7 +1893,7 @@ int LocalReduce_Avg_REAL4(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1914,8 +1914,8 @@ int LocalReduce_Avg_REAL4(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd32( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd32( avg, scalar); +#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) @@ -1974,22 +1974,22 @@ int LocalReduce_Avg_REAL8(int i, int weight_on, const void * const weight, CCTK_ 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1997,17 +1997,17 @@ int LocalReduce_Avg_REAL8(int i, int weight_on, const void * const weight, CCTK_ 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2051,7 +2051,7 @@ int LocalReduce_Avg_REAL8(int i, int weight_on, const void * const weight, CCTK_ #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2072,8 +2072,8 @@ int LocalReduce_Avg_REAL8(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd8( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd8( avg, scalar); +#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) @@ -2092,7 +2092,7 @@ int LocalReduce_Avg_REAL8(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2113,8 +2113,8 @@ int LocalReduce_Avg_REAL8(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd16( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd16( avg, scalar); +#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) @@ -2134,7 +2134,7 @@ int LocalReduce_Avg_REAL8(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2155,8 +2155,8 @@ int LocalReduce_Avg_REAL8(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd32( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd32( avg, scalar); +#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) @@ -2183,7 +2183,7 @@ int LocalReduce_Avg_REAL8(int i, int weight_on, const void * const weight, CCTK_ } #endif -#ifdef CCTK_REAL16 +#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; @@ -2216,22 +2216,22 @@ int LocalReduce_Avg_REAL16(int i, int weight_on, const void * const weight, CCTK 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2239,17 +2239,17 @@ int LocalReduce_Avg_REAL16(int i, int weight_on, const void * const weight, CCTK 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 CCTK_REAL4 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2293,7 +2293,7 @@ int LocalReduce_Avg_REAL16(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2314,8 +2314,8 @@ int LocalReduce_Avg_REAL16(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd8( avg, scalar); +#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) @@ -2334,7 +2334,7 @@ int LocalReduce_Avg_REAL16(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2355,8 +2355,8 @@ int LocalReduce_Avg_REAL16(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd16( avg, scalar); +#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) @@ -2376,7 +2376,7 @@ int LocalReduce_Avg_REAL16(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2397,8 +2397,8 @@ int LocalReduce_Avg_REAL16(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd32( avg, scalar); +#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) @@ -2467,22 +2467,22 @@ int LocalReduce_Avg_COMPLEX(int i, int weight_on, const void * const weight, CCT 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2490,17 +2490,17 @@ int LocalReduce_Avg_COMPLEX(int i, int weight_on, const void * const weight, CCT 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2545,7 +2545,7 @@ int LocalReduce_Avg_COMPLEX(int i, int weight_on, const void * const weight, CCT #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2556,8 +2556,8 @@ int LocalReduce_Avg_COMPLEX(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd8( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd8( avg, scalar); +#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) @@ -2587,7 +2587,7 @@ int LocalReduce_Avg_COMPLEX(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2598,8 +2598,8 @@ int LocalReduce_Avg_COMPLEX(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd16( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd16( avg, scalar); +#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) @@ -2630,7 +2630,7 @@ int LocalReduce_Avg_COMPLEX(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2641,8 +2641,8 @@ int LocalReduce_Avg_COMPLEX(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd32( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd32( avg, scalar); +#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) @@ -2679,7 +2679,7 @@ int LocalReduce_Avg_COMPLEX(int i, int weight_on, const void * const weight, CCT } -#ifdef CCTK_COMPLEX8 +#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; @@ -2723,22 +2723,22 @@ int LocalReduce_Avg_COMPLEX8(int i, int weight_on, const void * const weight, CC 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2746,17 +2746,17 @@ int LocalReduce_Avg_COMPLEX8(int i, int weight_on, const void * const weight, CC 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2801,7 +2801,7 @@ int LocalReduce_Avg_COMPLEX8(int i, int weight_on, const void * const weight, CC #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2812,8 +2812,8 @@ int LocalReduce_Avg_COMPLEX8(int i, int weight_on, const void * const weight, CC #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_CmplxAdd8( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd8( avg, scalar); +#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) @@ -2843,7 +2843,7 @@ int LocalReduce_Avg_COMPLEX8(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2854,8 +2854,8 @@ int LocalReduce_Avg_COMPLEX8(int i, int weight_on, const void * const weight, CC #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_CmplxAdd16( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd16( avg, scalar); +#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) @@ -2886,7 +2886,7 @@ int LocalReduce_Avg_COMPLEX8(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2897,8 +2897,8 @@ int LocalReduce_Avg_COMPLEX8(int i, int weight_on, const void * const weight, CC #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_CmplxAdd32( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd32( avg, scalar); +#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) @@ -2935,7 +2935,7 @@ int LocalReduce_Avg_COMPLEX8(int i, int weight_on, const void * const weight, CC } #endif -#ifdef CCTK_COMPLEX16 +#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; @@ -2979,22 +2979,22 @@ int LocalReduce_Avg_COMPLEX16(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -3002,17 +3002,17 @@ int LocalReduce_Avg_COMPLEX16(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3057,7 +3057,7 @@ int LocalReduce_Avg_COMPLEX16(int i, int weight_on, const void * const weight, C #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3068,8 +3068,8 @@ int LocalReduce_Avg_COMPLEX16(int i, int weight_on, const void * const weight, C #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_CmplxAdd8( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd8( avg, scalar); +#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) @@ -3099,7 +3099,7 @@ int LocalReduce_Avg_COMPLEX16(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3110,8 +3110,8 @@ int LocalReduce_Avg_COMPLEX16(int i, int weight_on, const void * const weight, C #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_CmplxAdd16( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd16( avg, scalar); +#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) @@ -3142,7 +3142,7 @@ int LocalReduce_Avg_COMPLEX16(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3153,8 +3153,8 @@ int LocalReduce_Avg_COMPLEX16(int i, int weight_on, const void * const weight, C #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_CmplxAdd32( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd32( avg, scalar); +#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) @@ -3191,7 +3191,7 @@ int LocalReduce_Avg_COMPLEX16(int i, int weight_on, const void * const weight, C } #endif -#ifdef CCTK_COMPLEX32 +#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; @@ -3230,27 +3230,27 @@ int LocalReduce_Avg_COMPLEX32(int i, int weight_on, const void * const weight, C { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - 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) + 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -3258,17 +3258,17 @@ int LocalReduce_Avg_COMPLEX32(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3313,7 +3313,7 @@ int LocalReduce_Avg_COMPLEX32(int i, int weight_on, const void * const weight, C #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3324,8 +3324,8 @@ int LocalReduce_Avg_COMPLEX32(int i, int weight_on, const void * const weight, C #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_CmplxAdd8( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd8( avg, scalar); +#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) @@ -3355,7 +3355,7 @@ int LocalReduce_Avg_COMPLEX32(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3366,8 +3366,8 @@ int LocalReduce_Avg_COMPLEX32(int i, int weight_on, const void * const weight, C #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_CmplxAdd16( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd16( avg, scalar); +#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) @@ -3398,7 +3398,7 @@ int LocalReduce_Avg_COMPLEX32(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3409,8 +3409,8 @@ int LocalReduce_Avg_COMPLEX32(int i, int weight_on, const void * const weight, C #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_CmplxAdd32( avg, scalar); -#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight; avg = CCTK_CmplxAdd32( avg, scalar); +#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) diff --git a/src/Avg_Functions.h b/src/Avg_Functions.h index eaf50d6..95d3fd6 100644 --- a/src/Avg_Functions.h +++ b/src/Avg_Functions.h @@ -22,47 +22,47 @@ int LocalReduce_Avg_BYTE(int i, int weight_on, const void * const weight, CCTK_ int LocalReduce_Avg_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 CCTK_INT1 +#ifdef HAVE_CCTK_INT1 int LocalReduce_Avg_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); #endif -#ifdef CCTK_INT2 +#ifdef HAVE_CCTK_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); #endif -#ifdef CCTK_INT4 +#ifdef HAVE_CCTK_INT4 int LocalReduce_Avg_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); #endif -#ifdef CCTK_INT8 +#ifdef HAVE_CCTK_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); #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_REAL4 +#ifdef HAVE_CCTK_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); #endif -#ifdef CCTK_REAL8 +#ifdef HAVE_CCTK_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); #endif -#ifdef CCTK_REAL16 +#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); #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); -#ifdef CCTK_COMPLEX8 +#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); #endif -#ifdef CCTK_COMPLEX16 +#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); #endif -#ifdef CCTK_COMPLEX32 +#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); #endif diff --git a/src/CountFunctions.c b/src/CountFunctions.c index a29d13e..724d6db 100644 --- a/src/CountFunctions.c +++ b/src/CountFunctions.c @@ -49,22 +49,22 @@ int LocalReduce_Count_BYTE(int i, int weight_on, const void * const weight, CCTK case CCTK_VARIABLE_INT: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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; @@ -72,17 +72,17 @@ int LocalReduce_Count_BYTE(int i, int weight_on, const void * const weight, CCTK case CCTK_VARIABLE_REAL: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: 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; @@ -127,7 +127,7 @@ int LocalReduce_Count_BYTE(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -168,7 +168,7 @@ int LocalReduce_Count_BYTE(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -210,7 +210,7 @@ int LocalReduce_Count_BYTE(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -287,22 +287,22 @@ int LocalReduce_Count_INT(int i, int weight_on, const void * const weight, CCTK_ 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -310,17 +310,17 @@ int LocalReduce_Count_INT(int i, int weight_on, const void * const weight, CCTK_ 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 CCTK_REAL4 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -364,7 +364,7 @@ int LocalReduce_Count_INT(int i, int weight_on, const void * const weight, CCTK_ #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -405,7 +405,7 @@ int LocalReduce_Count_INT(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -446,7 +446,7 @@ int LocalReduce_Count_INT(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -490,7 +490,7 @@ int LocalReduce_Count_INT(int i, int weight_on, const void * const weight, CCTK_ return num_points; } -#ifdef CCTK_INT1 +#ifdef HAVE_CCTK_INT1 int LocalReduce_Count_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; @@ -523,22 +523,22 @@ int LocalReduce_Count_INT1(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_INT12 + #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 CCTK_INT14 + #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 CCTK_INT18 + #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; @@ -546,17 +546,17 @@ int LocalReduce_Count_INT1(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -600,7 +600,7 @@ int LocalReduce_Count_INT1(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -641,7 +641,7 @@ int LocalReduce_Count_INT1(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -683,7 +683,7 @@ int LocalReduce_Count_INT1(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -729,7 +729,7 @@ int LocalReduce_Count_INT1(int i, int weight_on, const void * const weight, CCTK } #endif -#ifdef CCTK_INT2 +#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; @@ -762,22 +762,22 @@ int LocalReduce_Count_INT2(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_INT22 + #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 CCTK_INT24 + #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 CCTK_INT28 + #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; @@ -785,17 +785,17 @@ int LocalReduce_Count_INT2(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -839,7 +839,7 @@ int LocalReduce_Count_INT2(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -880,7 +880,7 @@ int LocalReduce_Count_INT2(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -922,7 +922,7 @@ int LocalReduce_Count_INT2(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -968,7 +968,7 @@ int LocalReduce_Count_INT2(int i, int weight_on, const void * const weight, CCTK } #endif -#ifdef CCTK_INT4 +#ifdef HAVE_CCTK_INT4 int LocalReduce_Count_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; @@ -1001,22 +1001,22 @@ int LocalReduce_Count_INT4(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1024,17 +1024,17 @@ int LocalReduce_Count_INT4(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1078,7 +1078,7 @@ int LocalReduce_Count_INT4(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1119,7 +1119,7 @@ int LocalReduce_Count_INT4(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1161,7 +1161,7 @@ int LocalReduce_Count_INT4(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1207,7 +1207,7 @@ int LocalReduce_Count_INT4(int i, int weight_on, const void * const weight, CCTK } #endif -#ifdef CCTK_INT8 +#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; @@ -1240,22 +1240,22 @@ int LocalReduce_Count_INT8(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1263,17 +1263,17 @@ int LocalReduce_Count_INT8(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1317,7 +1317,7 @@ int LocalReduce_Count_INT8(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1358,7 +1358,7 @@ int LocalReduce_Count_INT8(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1400,7 +1400,7 @@ int LocalReduce_Count_INT8(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1478,22 +1478,22 @@ int LocalReduce_Count_REAL(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1501,17 +1501,17 @@ int LocalReduce_Count_REAL(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1555,7 +1555,7 @@ int LocalReduce_Count_REAL(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1596,7 +1596,7 @@ int LocalReduce_Count_REAL(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1638,7 +1638,7 @@ int LocalReduce_Count_REAL(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1683,7 +1683,7 @@ int LocalReduce_Count_REAL(int i, int weight_on, const void * const weight, CCTK return num_points; } -#ifdef CCTK_REAL4 +#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; @@ -1716,22 +1716,22 @@ int LocalReduce_Count_REAL4(int i, int weight_on, const void * const weight, CCT 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1739,17 +1739,17 @@ int LocalReduce_Count_REAL4(int i, int weight_on, const void * const weight, CCT 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1793,7 +1793,7 @@ int LocalReduce_Count_REAL4(int i, int weight_on, const void * const weight, CCT #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1834,7 +1834,7 @@ int LocalReduce_Count_REAL4(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1876,7 +1876,7 @@ int LocalReduce_Count_REAL4(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1922,7 +1922,7 @@ int LocalReduce_Count_REAL4(int i, int weight_on, const void * const weight, CCT } #endif -#ifdef CCTK_REAL8 +#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; @@ -1955,22 +1955,22 @@ int LocalReduce_Count_REAL8(int i, int weight_on, const void * const weight, CCT 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1978,17 +1978,17 @@ int LocalReduce_Count_REAL8(int i, int weight_on, const void * const weight, CCT 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2032,7 +2032,7 @@ int LocalReduce_Count_REAL8(int i, int weight_on, const void * const weight, CCT #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2073,7 +2073,7 @@ int LocalReduce_Count_REAL8(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2115,7 +2115,7 @@ int LocalReduce_Count_REAL8(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2162,7 +2162,7 @@ int LocalReduce_Count_REAL8(int i, int weight_on, const void * const weight, CCT } #endif -#ifdef CCTK_REAL16 +#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; @@ -2195,22 +2195,22 @@ int LocalReduce_Count_REAL16(int i, int weight_on, const void * const weight, CC 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2218,17 +2218,17 @@ int LocalReduce_Count_REAL16(int i, int weight_on, const void * const weight, CC 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 CCTK_REAL4 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2272,7 +2272,7 @@ int LocalReduce_Count_REAL16(int i, int weight_on, const void * const weight, CC #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2313,7 +2313,7 @@ int LocalReduce_Count_REAL16(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2355,7 +2355,7 @@ int LocalReduce_Count_REAL16(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2444,22 +2444,22 @@ int LocalReduce_Count_COMPLEX(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2467,17 +2467,17 @@ int LocalReduce_Count_COMPLEX(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2522,7 +2522,7 @@ int LocalReduce_Count_COMPLEX(int i, int weight_on, const void * const weight, C #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2564,7 +2564,7 @@ int LocalReduce_Count_COMPLEX(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2607,7 +2607,7 @@ int LocalReduce_Count_COMPLEX(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2654,7 +2654,7 @@ int LocalReduce_Count_COMPLEX(int i, int weight_on, const void * const weight, C } -#ifdef CCTK_COMPLEX8 +#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; @@ -2698,22 +2698,22 @@ int LocalReduce_Count_COMPLEX8(int i, int weight_on, const void * const weight, 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2721,17 +2721,17 @@ int LocalReduce_Count_COMPLEX8(int i, int weight_on, const void * const weight, 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2776,7 +2776,7 @@ int LocalReduce_Count_COMPLEX8(int i, int weight_on, const void * const weight, #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2818,7 +2818,7 @@ int LocalReduce_Count_COMPLEX8(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2861,7 +2861,7 @@ int LocalReduce_Count_COMPLEX8(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2908,7 +2908,7 @@ int LocalReduce_Count_COMPLEX8(int i, int weight_on, const void * const weight, } #endif -#ifdef CCTK_COMPLEX16 +#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; @@ -2952,22 +2952,22 @@ int LocalReduce_Count_COMPLEX16(int i, int weight_on, const void * const weight, 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2975,17 +2975,17 @@ int LocalReduce_Count_COMPLEX16(int i, int weight_on, const void * const weight, 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3030,7 +3030,7 @@ int LocalReduce_Count_COMPLEX16(int i, int weight_on, const void * const weight, #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3072,7 +3072,7 @@ int LocalReduce_Count_COMPLEX16(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3115,7 +3115,7 @@ int LocalReduce_Count_COMPLEX16(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3162,7 +3162,7 @@ int LocalReduce_Count_COMPLEX16(int i, int weight_on, const void * const weight, } #endif -#ifdef CCTK_COMPLEX32 +#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; @@ -3201,27 +3201,27 @@ int LocalReduce_Count_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_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -3229,17 +3229,17 @@ int LocalReduce_Count_COMPLEX32(int i, int weight_on, const void * const weight, 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3284,7 +3284,7 @@ int LocalReduce_Count_COMPLEX32(int i, int weight_on, const void * const weight, #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3326,7 +3326,7 @@ int LocalReduce_Count_COMPLEX32(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3369,7 +3369,7 @@ int LocalReduce_Count_COMPLEX32(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION diff --git a/src/Count_Functions.h b/src/Count_Functions.h index 66f27ca..d5cf582 100644 --- a/src/Count_Functions.h +++ b/src/Count_Functions.h @@ -22,47 +22,47 @@ int LocalReduce_Count_BYTE(int i, int weight_on, const void * const weight, CCTK int LocalReduce_Count_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 CCTK_INT1 +#ifdef HAVE_CCTK_INT1 int LocalReduce_Count_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); #endif -#ifdef CCTK_INT2 +#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); #endif -#ifdef CCTK_INT4 +#ifdef HAVE_CCTK_INT4 int LocalReduce_Count_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); #endif -#ifdef CCTK_INT8 +#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); #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 CCTK_REAL4 +#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); #endif -#ifdef CCTK_REAL8 +#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); #endif -#ifdef CCTK_REAL16 +#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); #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); -#ifdef CCTK_COMPLEX8 +#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); #endif -#ifdef CCTK_COMPLEX16 +#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); #endif -#ifdef CCTK_COMPLEX32 +#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); #endif diff --git a/src/MaxFunctions.c b/src/MaxFunctions.c index b33381e..7a8b4c0 100644 --- a/src/MaxFunctions.c +++ b/src/MaxFunctions.c @@ -51,22 +51,22 @@ int LocalReduce_Max_BYTE(int i, int weight_on, const void * const weight, CCTK_I case CCTK_VARIABLE_INT: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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; @@ -74,17 +74,17 @@ int LocalReduce_Max_BYTE(int i, int weight_on, const void * const weight, CCTK_I case CCTK_VARIABLE_REAL: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: 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; @@ -129,7 +129,7 @@ int LocalReduce_Max_BYTE(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -170,7 +170,7 @@ int LocalReduce_Max_BYTE(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -212,7 +212,7 @@ int LocalReduce_Max_BYTE(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -292,22 +292,22 @@ int LocalReduce_Max_INT(int i, int weight_on, const void * const weight, CCTK_IN 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -315,17 +315,17 @@ int LocalReduce_Max_INT(int i, int weight_on, const void * const weight, CCTK_IN 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 CCTK_REAL4 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -369,7 +369,7 @@ int LocalReduce_Max_INT(int i, int weight_on, const void * const weight, CCTK_IN #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -410,7 +410,7 @@ int LocalReduce_Max_INT(int i, int weight_on, const void * const weight, CCTK_IN break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -451,7 +451,7 @@ int LocalReduce_Max_INT(int i, int weight_on, const void * const weight, CCTK_IN break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -530,22 +530,22 @@ int LocalReduce_Max_INT1(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_INT12 + #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 CCTK_INT14 + #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 CCTK_INT18 + #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; @@ -553,17 +553,17 @@ int LocalReduce_Max_INT1(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -607,7 +607,7 @@ int LocalReduce_Max_INT1(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -648,7 +648,7 @@ int LocalReduce_Max_INT1(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -690,7 +690,7 @@ int LocalReduce_Max_INT1(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -771,22 +771,22 @@ int LocalReduce_Max_INT2(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_INT22 + #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 CCTK_INT24 + #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 CCTK_INT28 + #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; @@ -794,17 +794,17 @@ int LocalReduce_Max_INT2(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -848,7 +848,7 @@ int LocalReduce_Max_INT2(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -889,7 +889,7 @@ int LocalReduce_Max_INT2(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -931,7 +931,7 @@ int LocalReduce_Max_INT2(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1012,22 +1012,22 @@ int LocalReduce_Max_INT4(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1035,17 +1035,17 @@ int LocalReduce_Max_INT4(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1089,7 +1089,7 @@ int LocalReduce_Max_INT4(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1130,7 +1130,7 @@ int LocalReduce_Max_INT4(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1172,7 +1172,7 @@ int LocalReduce_Max_INT4(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1253,22 +1253,22 @@ int LocalReduce_Max_INT8(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1276,17 +1276,17 @@ int LocalReduce_Max_INT8(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1330,7 +1330,7 @@ int LocalReduce_Max_INT8(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1371,7 +1371,7 @@ int LocalReduce_Max_INT8(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1413,7 +1413,7 @@ int LocalReduce_Max_INT8(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1493,22 +1493,22 @@ int LocalReduce_Max_REAL(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1516,17 +1516,17 @@ int LocalReduce_Max_REAL(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1570,7 +1570,7 @@ int LocalReduce_Max_REAL(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1611,7 +1611,7 @@ int LocalReduce_Max_REAL(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1653,7 +1653,7 @@ int LocalReduce_Max_REAL(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1733,22 +1733,22 @@ int LocalReduce_Max_REAL4(int i, int weight_on, const void * const weight, CCTK_ 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1756,17 +1756,17 @@ int LocalReduce_Max_REAL4(int i, int weight_on, const void * const weight, CCTK_ 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1810,7 +1810,7 @@ int LocalReduce_Max_REAL4(int i, int weight_on, const void * const weight, CCTK_ #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1851,7 +1851,7 @@ int LocalReduce_Max_REAL4(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1893,7 +1893,7 @@ int LocalReduce_Max_REAL4(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1974,22 +1974,22 @@ int LocalReduce_Max_REAL8(int i, int weight_on, const void * const weight, CCTK_ 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1997,17 +1997,17 @@ int LocalReduce_Max_REAL8(int i, int weight_on, const void * const weight, CCTK_ 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2051,7 +2051,7 @@ int LocalReduce_Max_REAL8(int i, int weight_on, const void * const weight, CCTK_ #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2092,7 +2092,7 @@ int LocalReduce_Max_REAL8(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2134,7 +2134,7 @@ int LocalReduce_Max_REAL8(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2183,7 +2183,7 @@ int LocalReduce_Max_REAL8(int i, int weight_on, const void * const weight, CCTK_ } #endif -#ifdef CCTK_REAL16 +#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; @@ -2216,22 +2216,22 @@ int LocalReduce_Max_REAL16(int i, int weight_on, const void * const weight, CCTK 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2239,17 +2239,17 @@ int LocalReduce_Max_REAL16(int i, int weight_on, const void * const weight, CCTK 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 CCTK_REAL4 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2293,7 +2293,7 @@ int LocalReduce_Max_REAL16(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2334,7 +2334,7 @@ int LocalReduce_Max_REAL16(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2376,7 +2376,7 @@ int LocalReduce_Max_REAL16(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2467,22 +2467,22 @@ int LocalReduce_Max_COMPLEX(int i, int weight_on, const void * const weight, CCT 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2490,17 +2490,17 @@ int LocalReduce_Max_COMPLEX(int i, int weight_on, const void * const weight, CCT 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2545,7 +2545,7 @@ int LocalReduce_Max_COMPLEX(int i, int weight_on, const void * const weight, CCT #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2587,7 +2587,7 @@ int LocalReduce_Max_COMPLEX(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2630,7 +2630,7 @@ int LocalReduce_Max_COMPLEX(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2679,7 +2679,7 @@ int LocalReduce_Max_COMPLEX(int i, int weight_on, const void * const weight, CCT } -#ifdef CCTK_COMPLEX8 +#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; @@ -2723,22 +2723,22 @@ int LocalReduce_Max_COMPLEX8(int i, int weight_on, const void * const weight, CC 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2746,17 +2746,17 @@ int LocalReduce_Max_COMPLEX8(int i, int weight_on, const void * const weight, CC 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2801,7 +2801,7 @@ int LocalReduce_Max_COMPLEX8(int i, int weight_on, const void * const weight, CC #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2843,7 +2843,7 @@ int LocalReduce_Max_COMPLEX8(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2886,7 +2886,7 @@ int LocalReduce_Max_COMPLEX8(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2935,7 +2935,7 @@ int LocalReduce_Max_COMPLEX8(int i, int weight_on, const void * const weight, CC } #endif -#ifdef CCTK_COMPLEX16 +#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; @@ -2979,22 +2979,22 @@ int LocalReduce_Max_COMPLEX16(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -3002,17 +3002,17 @@ int LocalReduce_Max_COMPLEX16(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3057,7 +3057,7 @@ int LocalReduce_Max_COMPLEX16(int i, int weight_on, const void * const weight, C #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3099,7 +3099,7 @@ int LocalReduce_Max_COMPLEX16(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3142,7 +3142,7 @@ int LocalReduce_Max_COMPLEX16(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3191,7 +3191,7 @@ int LocalReduce_Max_COMPLEX16(int i, int weight_on, const void * const weight, C } #endif -#ifdef CCTK_COMPLEX32 +#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; @@ -3230,27 +3230,27 @@ int LocalReduce_Max_COMPLEX32(int i, int weight_on, const void * const weight, C { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - 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) + 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -3258,17 +3258,17 @@ int LocalReduce_Max_COMPLEX32(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3313,7 +3313,7 @@ int LocalReduce_Max_COMPLEX32(int i, int weight_on, const void * const weight, C #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3355,7 +3355,7 @@ int LocalReduce_Max_COMPLEX32(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3398,7 +3398,7 @@ int LocalReduce_Max_COMPLEX32(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION diff --git a/src/Max_Functions.h b/src/Max_Functions.h index 1ce9fc9..37b2de0 100644 --- a/src/Max_Functions.h +++ b/src/Max_Functions.h @@ -22,47 +22,47 @@ int LocalReduce_Max_BYTE(int i, int weight_on, const void * const weight, CCTK_I int LocalReduce_Max_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 CCTK_INT1 +#ifdef HAVE_CCTK_INT1 int LocalReduce_Max_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); #endif -#ifdef CCTK_INT2 +#ifdef HAVE_CCTK_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); #endif -#ifdef CCTK_INT4 +#ifdef HAVE_CCTK_INT4 int LocalReduce_Max_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); #endif -#ifdef CCTK_INT8 +#ifdef HAVE_CCTK_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); #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_REAL4 +#ifdef HAVE_CCTK_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); #endif -#ifdef CCTK_REAL8 +#ifdef HAVE_CCTK_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); #endif -#ifdef CCTK_REAL16 +#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); #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); -#ifdef CCTK_COMPLEX8 +#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); #endif -#ifdef CCTK_COMPLEX16 +#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); #endif -#ifdef CCTK_COMPLEX32 +#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); #endif diff --git a/src/MinFunctions.c b/src/MinFunctions.c index ec3ef10..f3b8204 100644 --- a/src/MinFunctions.c +++ b/src/MinFunctions.c @@ -49,22 +49,22 @@ int LocalReduce_Min_BYTE(int i, int weight_on, const void * const weight, CCTK_I case CCTK_VARIABLE_INT: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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; @@ -72,17 +72,17 @@ int LocalReduce_Min_BYTE(int i, int weight_on, const void * const weight, CCTK_I case CCTK_VARIABLE_REAL: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: 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; @@ -127,7 +127,7 @@ int LocalReduce_Min_BYTE(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -168,7 +168,7 @@ int LocalReduce_Min_BYTE(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -210,7 +210,7 @@ int LocalReduce_Min_BYTE(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -289,22 +289,22 @@ int LocalReduce_Min_INT(int i, int weight_on, const void * const weight, CCTK_IN 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -312,17 +312,17 @@ int LocalReduce_Min_INT(int i, int weight_on, const void * const weight, CCTK_IN 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 CCTK_REAL4 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -366,7 +366,7 @@ int LocalReduce_Min_INT(int i, int weight_on, const void * const weight, CCTK_IN #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -407,7 +407,7 @@ int LocalReduce_Min_INT(int i, int weight_on, const void * const weight, CCTK_IN break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -448,7 +448,7 @@ int LocalReduce_Min_INT(int i, int weight_on, const void * const weight, CCTK_IN break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -492,7 +492,7 @@ int LocalReduce_Min_INT(int i, int weight_on, const void * const weight, CCTK_IN return num_points; } -#ifdef CCTK_INT1 +#ifdef HAVE_CCTK_INT1 int LocalReduce_Min_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; @@ -525,22 +525,22 @@ int LocalReduce_Min_INT1(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_INT12 + #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 CCTK_INT14 + #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 CCTK_INT18 + #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; @@ -548,17 +548,17 @@ int LocalReduce_Min_INT1(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -602,7 +602,7 @@ int LocalReduce_Min_INT1(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -643,7 +643,7 @@ int LocalReduce_Min_INT1(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -685,7 +685,7 @@ int LocalReduce_Min_INT1(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -731,7 +731,7 @@ int LocalReduce_Min_INT1(int i, int weight_on, const void * const weight, CCTK_I } #endif -#ifdef CCTK_INT2 +#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; @@ -764,22 +764,22 @@ int LocalReduce_Min_INT2(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_INT22 + #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 CCTK_INT24 + #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 CCTK_INT28 + #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; @@ -787,17 +787,17 @@ int LocalReduce_Min_INT2(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -841,7 +841,7 @@ int LocalReduce_Min_INT2(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -882,7 +882,7 @@ int LocalReduce_Min_INT2(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -924,7 +924,7 @@ int LocalReduce_Min_INT2(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -970,7 +970,7 @@ int LocalReduce_Min_INT2(int i, int weight_on, const void * const weight, CCTK_I } #endif -#ifdef CCTK_INT4 +#ifdef HAVE_CCTK_INT4 int LocalReduce_Min_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; @@ -1003,22 +1003,22 @@ int LocalReduce_Min_INT4(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1026,17 +1026,17 @@ int LocalReduce_Min_INT4(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1080,7 +1080,7 @@ int LocalReduce_Min_INT4(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1121,7 +1121,7 @@ int LocalReduce_Min_INT4(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1163,7 +1163,7 @@ int LocalReduce_Min_INT4(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1209,7 +1209,7 @@ int LocalReduce_Min_INT4(int i, int weight_on, const void * const weight, CCTK_I } #endif -#ifdef CCTK_INT8 +#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; @@ -1242,22 +1242,22 @@ int LocalReduce_Min_INT8(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1265,17 +1265,17 @@ int LocalReduce_Min_INT8(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1319,7 +1319,7 @@ int LocalReduce_Min_INT8(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1360,7 +1360,7 @@ int LocalReduce_Min_INT8(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1402,7 +1402,7 @@ int LocalReduce_Min_INT8(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1480,22 +1480,22 @@ int LocalReduce_Min_REAL(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1503,17 +1503,17 @@ int LocalReduce_Min_REAL(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1557,7 +1557,7 @@ int LocalReduce_Min_REAL(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1598,7 +1598,7 @@ int LocalReduce_Min_REAL(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1640,7 +1640,7 @@ int LocalReduce_Min_REAL(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1685,7 +1685,7 @@ int LocalReduce_Min_REAL(int i, int weight_on, const void * const weight, CCTK_I return num_points; } -#ifdef CCTK_REAL4 +#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; @@ -1718,22 +1718,22 @@ int LocalReduce_Min_REAL4(int i, int weight_on, const void * const weight, CCTK_ 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1741,17 +1741,17 @@ int LocalReduce_Min_REAL4(int i, int weight_on, const void * const weight, CCTK_ 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1795,7 +1795,7 @@ int LocalReduce_Min_REAL4(int i, int weight_on, const void * const weight, CCTK_ #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1836,7 +1836,7 @@ int LocalReduce_Min_REAL4(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1878,7 +1878,7 @@ int LocalReduce_Min_REAL4(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1924,7 +1924,7 @@ int LocalReduce_Min_REAL4(int i, int weight_on, const void * const weight, CCTK_ } #endif -#ifdef CCTK_REAL8 +#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; @@ -1957,22 +1957,22 @@ int LocalReduce_Min_REAL8(int i, int weight_on, const void * const weight, CCTK_ 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1980,17 +1980,17 @@ int LocalReduce_Min_REAL8(int i, int weight_on, const void * const weight, CCTK_ 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2034,7 +2034,7 @@ int LocalReduce_Min_REAL8(int i, int weight_on, const void * const weight, CCTK_ #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2075,7 +2075,7 @@ int LocalReduce_Min_REAL8(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2117,7 +2117,7 @@ int LocalReduce_Min_REAL8(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2164,7 +2164,7 @@ int LocalReduce_Min_REAL8(int i, int weight_on, const void * const weight, CCTK_ } #endif -#ifdef CCTK_REAL16 +#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; @@ -2197,22 +2197,22 @@ int LocalReduce_Min_REAL16(int i, int weight_on, const void * const weight, CCTK 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2220,17 +2220,17 @@ int LocalReduce_Min_REAL16(int i, int weight_on, const void * const weight, CCTK 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 CCTK_REAL4 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2274,7 +2274,7 @@ int LocalReduce_Min_REAL16(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2315,7 +2315,7 @@ int LocalReduce_Min_REAL16(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2357,7 +2357,7 @@ int LocalReduce_Min_REAL16(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2446,22 +2446,22 @@ int LocalReduce_Min_COMPLEX(int i, int weight_on, const void * const weight, CCT 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2469,17 +2469,17 @@ int LocalReduce_Min_COMPLEX(int i, int weight_on, const void * const weight, CCT 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2524,7 +2524,7 @@ int LocalReduce_Min_COMPLEX(int i, int weight_on, const void * const weight, CCT #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2566,7 +2566,7 @@ int LocalReduce_Min_COMPLEX(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2609,7 +2609,7 @@ int LocalReduce_Min_COMPLEX(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2656,7 +2656,7 @@ int LocalReduce_Min_COMPLEX(int i, int weight_on, const void * const weight, CCT } -#ifdef CCTK_COMPLEX8 +#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; @@ -2700,22 +2700,22 @@ int LocalReduce_Min_COMPLEX8(int i, int weight_on, const void * const weight, CC 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2723,17 +2723,17 @@ int LocalReduce_Min_COMPLEX8(int i, int weight_on, const void * const weight, CC 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2778,7 +2778,7 @@ int LocalReduce_Min_COMPLEX8(int i, int weight_on, const void * const weight, CC #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2820,7 +2820,7 @@ int LocalReduce_Min_COMPLEX8(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2863,7 +2863,7 @@ int LocalReduce_Min_COMPLEX8(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2910,7 +2910,7 @@ int LocalReduce_Min_COMPLEX8(int i, int weight_on, const void * const weight, CC } #endif -#ifdef CCTK_COMPLEX16 +#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; @@ -2954,22 +2954,22 @@ int LocalReduce_Min_COMPLEX16(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2977,17 +2977,17 @@ int LocalReduce_Min_COMPLEX16(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3032,7 +3032,7 @@ int LocalReduce_Min_COMPLEX16(int i, int weight_on, const void * const weight, C #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3074,7 +3074,7 @@ int LocalReduce_Min_COMPLEX16(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3117,7 +3117,7 @@ int LocalReduce_Min_COMPLEX16(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3164,7 +3164,7 @@ int LocalReduce_Min_COMPLEX16(int i, int weight_on, const void * const weight, C } #endif -#ifdef CCTK_COMPLEX32 +#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; @@ -3203,27 +3203,27 @@ int LocalReduce_Min_COMPLEX32(int i, int weight_on, const void * const weight, C { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - 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) + 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -3231,17 +3231,17 @@ int LocalReduce_Min_COMPLEX32(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3286,7 +3286,7 @@ int LocalReduce_Min_COMPLEX32(int i, int weight_on, const void * const weight, C #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3328,7 +3328,7 @@ int LocalReduce_Min_COMPLEX32(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3371,7 +3371,7 @@ int LocalReduce_Min_COMPLEX32(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION diff --git a/src/Min_Functions.h b/src/Min_Functions.h index a3efe12..28e536e 100644 --- a/src/Min_Functions.h +++ b/src/Min_Functions.h @@ -22,47 +22,47 @@ int LocalReduce_Min_BYTE(int i, int weight_on, const void * const weight, CCTK_I int LocalReduce_Min_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 CCTK_INT1 +#ifdef HAVE_CCTK_INT1 int LocalReduce_Min_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); #endif -#ifdef CCTK_INT2 +#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); #endif -#ifdef CCTK_INT4 +#ifdef HAVE_CCTK_INT4 int LocalReduce_Min_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); #endif -#ifdef CCTK_INT8 +#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); #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 CCTK_REAL4 +#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); #endif -#ifdef CCTK_REAL8 +#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); #endif -#ifdef CCTK_REAL16 +#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); #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); -#ifdef CCTK_COMPLEX8 +#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); #endif -#ifdef CCTK_COMPLEX16 +#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); #endif -#ifdef CCTK_COMPLEX32 +#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); #endif diff --git a/src/Norm1Functions.c b/src/Norm1Functions.c index 8777d86..5e4713f 100644 --- a/src/Norm1Functions.c +++ b/src/Norm1Functions.c @@ -140,7 +140,7 @@ int LocalReduce_Norm1_BYTE(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -165,8 +165,8 @@ int LocalReduce_Norm1_BYTE(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd8( Norm1, scalar); +#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) @@ -189,7 +189,7 @@ int LocalReduce_Norm1_BYTE(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -214,8 +214,8 @@ int LocalReduce_Norm1_BYTE(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd16( Norm1, scalar); +#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) @@ -239,7 +239,7 @@ int LocalReduce_Norm1_BYTE(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -264,8 +264,8 @@ int LocalReduce_Norm1_BYTE(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd32( Norm1, scalar); +#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) @@ -416,7 +416,7 @@ int LocalReduce_Norm1_INT(int i, int weight_on, const void * const weight, CCTK_ #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -441,8 +441,8 @@ int LocalReduce_Norm1_INT(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd8( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd8( Norm1, scalar); +#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) @@ -465,7 +465,7 @@ int LocalReduce_Norm1_INT(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -490,8 +490,8 @@ int LocalReduce_Norm1_INT(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd16( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd16( Norm1, scalar); +#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) @@ -514,7 +514,7 @@ int LocalReduce_Norm1_INT(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -539,8 +539,8 @@ int LocalReduce_Norm1_INT(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd32( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd32( Norm1, scalar); +#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) @@ -691,7 +691,7 @@ int LocalReduce_Norm1_INT1(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -716,8 +716,8 @@ int LocalReduce_Norm1_INT1(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd8( Norm1, scalar); +#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) @@ -740,7 +740,7 @@ int LocalReduce_Norm1_INT1(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -765,8 +765,8 @@ int LocalReduce_Norm1_INT1(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd16( Norm1, scalar); +#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) @@ -790,7 +790,7 @@ int LocalReduce_Norm1_INT1(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -815,8 +815,8 @@ int LocalReduce_Norm1_INT1(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd32( Norm1, scalar); +#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) @@ -969,7 +969,7 @@ int LocalReduce_Norm1_INT2(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -994,8 +994,8 @@ int LocalReduce_Norm1_INT2(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd8( Norm1, scalar); +#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) @@ -1018,7 +1018,7 @@ int LocalReduce_Norm1_INT2(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1043,8 +1043,8 @@ int LocalReduce_Norm1_INT2(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd16( Norm1, scalar); +#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) @@ -1068,7 +1068,7 @@ int LocalReduce_Norm1_INT2(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1093,8 +1093,8 @@ int LocalReduce_Norm1_INT2(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd32( Norm1, scalar); +#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) @@ -1247,7 +1247,7 @@ int LocalReduce_Norm1_INT4(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1272,8 +1272,8 @@ int LocalReduce_Norm1_INT4(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd8( Norm1, scalar); +#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) @@ -1296,7 +1296,7 @@ int LocalReduce_Norm1_INT4(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1321,8 +1321,8 @@ int LocalReduce_Norm1_INT4(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd16( Norm1, scalar); +#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) @@ -1346,7 +1346,7 @@ int LocalReduce_Norm1_INT4(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1371,8 +1371,8 @@ int LocalReduce_Norm1_INT4(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd32( Norm1, scalar); +#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) @@ -1525,7 +1525,7 @@ int LocalReduce_Norm1_INT8(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1550,8 +1550,8 @@ int LocalReduce_Norm1_INT8(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd8( Norm1, scalar); +#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) @@ -1574,7 +1574,7 @@ int LocalReduce_Norm1_INT8(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1599,8 +1599,8 @@ int LocalReduce_Norm1_INT8(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd16( Norm1, scalar); +#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) @@ -1624,7 +1624,7 @@ int LocalReduce_Norm1_INT8(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1649,8 +1649,8 @@ int LocalReduce_Norm1_INT8(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd32( Norm1, scalar); +#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) @@ -1802,7 +1802,7 @@ int LocalReduce_Norm1_REAL(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1827,8 +1827,8 @@ int LocalReduce_Norm1_REAL(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd8( Norm1, scalar); +#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) @@ -1851,7 +1851,7 @@ int LocalReduce_Norm1_REAL(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1876,8 +1876,8 @@ int LocalReduce_Norm1_REAL(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd16( Norm1, scalar); +#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) @@ -1901,7 +1901,7 @@ int LocalReduce_Norm1_REAL(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1926,8 +1926,8 @@ int LocalReduce_Norm1_REAL(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd32( Norm1, scalar); +#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) @@ -2079,7 +2079,7 @@ int LocalReduce_Norm1_REAL4(int i, int weight_on, const void * const weight, CCT #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2104,8 +2104,8 @@ int LocalReduce_Norm1_REAL4(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd8( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd8( Norm1, scalar); +#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) @@ -2128,7 +2128,7 @@ int LocalReduce_Norm1_REAL4(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2153,8 +2153,8 @@ int LocalReduce_Norm1_REAL4(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd16( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd16( Norm1, scalar); +#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) @@ -2178,7 +2178,7 @@ int LocalReduce_Norm1_REAL4(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2203,8 +2203,8 @@ int LocalReduce_Norm1_REAL4(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd32( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd32( Norm1, scalar); +#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) @@ -2357,7 +2357,7 @@ int LocalReduce_Norm1_REAL8(int i, int weight_on, const void * const weight, CCT #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2382,8 +2382,8 @@ int LocalReduce_Norm1_REAL8(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd8( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd8( Norm1, scalar); +#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) @@ -2406,7 +2406,7 @@ int LocalReduce_Norm1_REAL8(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2431,8 +2431,8 @@ int LocalReduce_Norm1_REAL8(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd16( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd16( Norm1, scalar); +#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) @@ -2456,7 +2456,7 @@ int LocalReduce_Norm1_REAL8(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2481,8 +2481,8 @@ int LocalReduce_Norm1_REAL8(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd32( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd32( Norm1, scalar); +#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) @@ -2636,7 +2636,7 @@ int LocalReduce_Norm1_REAL16(int i, int weight_on, const void * const weight, CC #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2661,8 +2661,8 @@ int LocalReduce_Norm1_REAL16(int i, int weight_on, const void * const weight, CC #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_CmplxAdd8( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd8( Norm1, scalar); +#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) @@ -2685,7 +2685,7 @@ int LocalReduce_Norm1_REAL16(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2710,8 +2710,8 @@ int LocalReduce_Norm1_REAL16(int i, int weight_on, const void * const weight, CC #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_CmplxAdd16( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd16( Norm1, scalar); +#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) @@ -2735,7 +2735,7 @@ int LocalReduce_Norm1_REAL16(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2760,8 +2760,8 @@ int LocalReduce_Norm1_REAL16(int i, int weight_on, const void * const weight, CC #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_CmplxAdd32( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd32( Norm1, scalar); +#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) @@ -2917,7 +2917,7 @@ int LocalReduce_Norm1_COMPLEX(int i, int weight_on, const void * const weight, C #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2932,8 +2932,8 @@ int LocalReduce_Norm1_COMPLEX(int i, int weight_on, const void * const weight, C #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_CmplxAdd8( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd8( Norm1, scalar); +#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) @@ -2963,7 +2963,7 @@ int LocalReduce_Norm1_COMPLEX(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2978,8 +2978,8 @@ int LocalReduce_Norm1_COMPLEX(int i, int weight_on, const void * const weight, C #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_CmplxAdd16( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd16( Norm1, scalar); +#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) @@ -3010,7 +3010,7 @@ int LocalReduce_Norm1_COMPLEX(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3025,8 +3025,8 @@ int LocalReduce_Norm1_COMPLEX(int i, int weight_on, const void * const weight, C #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_CmplxAdd32( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd32( Norm1, scalar); +#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) @@ -3064,7 +3064,7 @@ int LocalReduce_Norm1_COMPLEX(int i, int weight_on, const void * const weight, C } -#ifdef CCTK_COMPLEX8 +#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; @@ -3080,19 +3080,9 @@ int LocalReduce_Norm1_COMPLEX8(int i, int weight_on, const void * const weight, #undef REDUCTION_INITIAL #undef EXTRA_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; @@ -3170,19 +3160,9 @@ int LocalReduce_Norm1_COMPLEX8(int i, int weight_on, const void * const weight, #undef REDUCTION_INITIAL #undef EXTRA_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; @@ -3190,7 +3170,7 @@ int LocalReduce_Norm1_COMPLEX8(int i, int weight_on, const void * const weight, #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3205,8 +3185,8 @@ int LocalReduce_Norm1_COMPLEX8(int i, int weight_on, const void * const weight, #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_CmplxAdd8( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd8( Norm1, scalar); +#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) @@ -3215,19 +3195,9 @@ int LocalReduce_Norm1_COMPLEX8(int i, int weight_on, const void * const weight, #undef REDUCTION_INITIAL #undef EXTRA_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; @@ -3236,7 +3206,7 @@ int LocalReduce_Norm1_COMPLEX8(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3251,8 +3221,8 @@ int LocalReduce_Norm1_COMPLEX8(int i, int weight_on, const void * const weight, #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_CmplxAdd16( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd16( Norm1, scalar); +#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) @@ -3262,19 +3232,9 @@ int LocalReduce_Norm1_COMPLEX8(int i, int weight_on, const void * const weight, #undef REDUCTION_INITIAL #undef EXTRA_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; @@ -3283,7 +3243,7 @@ int LocalReduce_Norm1_COMPLEX8(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3298,8 +3258,8 @@ int LocalReduce_Norm1_COMPLEX8(int i, int weight_on, const void * const weight, #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_CmplxAdd32( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd32( Norm1, scalar); +#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) @@ -3309,19 +3269,9 @@ int LocalReduce_Norm1_COMPLEX8(int i, int weight_on, const void * const weight, #undef REDUCTION_INITIAL #undef EXTRA_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; @@ -3337,7 +3287,7 @@ int LocalReduce_Norm1_COMPLEX8(int i, int weight_on, const void * const weight, } #endif -#ifdef CCTK_COMPLEX16 +#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; @@ -3463,7 +3413,7 @@ int LocalReduce_Norm1_COMPLEX16(int i, int weight_on, const void * const weight, #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3478,8 +3428,8 @@ int LocalReduce_Norm1_COMPLEX16(int i, int weight_on, const void * const weight, #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_CmplxAdd8( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd8( Norm1, scalar); +#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) @@ -3509,7 +3459,7 @@ int LocalReduce_Norm1_COMPLEX16(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3524,8 +3474,8 @@ int LocalReduce_Norm1_COMPLEX16(int i, int weight_on, const void * const weight, #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_CmplxAdd16( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd16( Norm1, scalar); +#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) @@ -3556,7 +3506,7 @@ int LocalReduce_Norm1_COMPLEX16(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3571,8 +3521,8 @@ int LocalReduce_Norm1_COMPLEX16(int i, int weight_on, const void * const weight, #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_CmplxAdd32( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd32( Norm1, scalar); +#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) @@ -3610,7 +3560,7 @@ int LocalReduce_Norm1_COMPLEX16(int i, int weight_on, const void * const weight, } #endif -#ifdef CCTK_COMPLEX32 +#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; @@ -3626,19 +3576,9 @@ int LocalReduce_Norm1_COMPLEX32(int i, int weight_on, const void * const weight, #undef REDUCTION_INITIAL #undef EXTRA_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; @@ -3649,7 +3589,7 @@ 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_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + 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) @@ -3716,19 +3656,9 @@ int LocalReduce_Norm1_COMPLEX32(int i, int weight_on, const void * const weight, #undef REDUCTION_INITIAL #undef EXTRA_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; @@ -3736,7 +3666,7 @@ int LocalReduce_Norm1_COMPLEX32(int i, int weight_on, const void * const weight, #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3751,8 +3681,8 @@ int LocalReduce_Norm1_COMPLEX32(int i, int weight_on, const void * const weight, #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_CmplxAdd8( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd8( Norm1, scalar); +#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) @@ -3761,19 +3691,9 @@ int LocalReduce_Norm1_COMPLEX32(int i, int weight_on, const void * const weight, #undef REDUCTION_INITIAL #undef EXTRA_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; @@ -3782,7 +3702,7 @@ int LocalReduce_Norm1_COMPLEX32(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3797,8 +3717,8 @@ int LocalReduce_Norm1_COMPLEX32(int i, int weight_on, const void * const weight, #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_CmplxAdd16( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd16( Norm1, scalar); +#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) @@ -3808,19 +3728,9 @@ int LocalReduce_Norm1_COMPLEX32(int i, int weight_on, const void * const weight, #undef REDUCTION_INITIAL #undef EXTRA_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; @@ -3829,7 +3739,7 @@ int LocalReduce_Norm1_COMPLEX32(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3844,8 +3754,8 @@ int LocalReduce_Norm1_COMPLEX32(int i, int weight_on, const void * const weight, #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_CmplxAdd32( Norm1, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd32( Norm1, scalar); +#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) @@ -3855,19 +3765,9 @@ int LocalReduce_Norm1_COMPLEX32(int i, int weight_on, const void * const weight, #undef REDUCTION_INITIAL #undef EXTRA_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; diff --git a/src/Norm1_Functions.h b/src/Norm1_Functions.h index 554ec94..8fbfea9 100644 --- a/src/Norm1_Functions.h +++ b/src/Norm1_Functions.h @@ -22,47 +22,47 @@ int LocalReduce_Norm1_BYTE(int i, int weight_on, const void * const weight, CCTK int LocalReduce_Norm1_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 CCTK_INT1 +#ifdef HAVE_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); #endif -#ifdef CCTK_INT2 +#ifdef HAVE_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); #endif -#ifdef CCTK_INT4 +#ifdef HAVE_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); #endif -#ifdef CCTK_INT8 +#ifdef HAVE_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); #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); -#ifdef CCTK_REAL4 +#ifdef HAVE_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); #endif -#ifdef CCTK_REAL8 +#ifdef HAVE_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); #endif -#ifdef CCTK_REAL16 +#ifdef HAVE_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); #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); -#ifdef CCTK_COMPLEX8 +#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); #endif -#ifdef CCTK_COMPLEX16 +#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); #endif -#ifdef CCTK_COMPLEX32 +#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); #endif diff --git a/src/Norm2Functions.c b/src/Norm2Functions.c index ef5a9b3..deb863f 100644 --- a/src/Norm2Functions.c +++ b/src/Norm2Functions.c @@ -54,22 +54,22 @@ int LocalReduce_Norm2_BYTE(int i, int weight_on, const void * const weight, CCTK case CCTK_VARIABLE_INT: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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; @@ -77,17 +77,17 @@ int LocalReduce_Norm2_BYTE(int i, int weight_on, const void * const weight, CCTK case CCTK_VARIABLE_REAL: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: 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; @@ -140,7 +140,7 @@ int LocalReduce_Norm2_BYTE(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -165,8 +165,8 @@ int LocalReduce_Norm2_BYTE(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd8( Norm2, scalar); +#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) @@ -189,7 +189,7 @@ int LocalReduce_Norm2_BYTE(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -214,9 +214,9 @@ int LocalReduce_Norm2_BYTE(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); +#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) @@ -240,7 +240,7 @@ int LocalReduce_Norm2_BYTE(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -265,8 +265,8 @@ int LocalReduce_Norm2_BYTE(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd32( Norm2, scalar); +#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) @@ -331,22 +331,22 @@ int LocalReduce_Norm2_INT(int i, int weight_on, const void * const weight, CCTK_ 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -354,17 +354,17 @@ int LocalReduce_Norm2_INT(int i, int weight_on, const void * const weight, CCTK_ 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 CCTK_REAL4 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -416,7 +416,7 @@ int LocalReduce_Norm2_INT(int i, int weight_on, const void * const weight, CCTK_ #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -441,8 +441,8 @@ int LocalReduce_Norm2_INT(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd8( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd8( Norm2, scalar); +#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) @@ -465,7 +465,7 @@ int LocalReduce_Norm2_INT(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -490,9 +490,9 @@ int LocalReduce_Norm2_INT(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); +#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) @@ -515,7 +515,7 @@ int LocalReduce_Norm2_INT(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -540,8 +540,8 @@ int LocalReduce_Norm2_INT(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd32( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd32( Norm2, scalar); +#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) @@ -569,7 +569,7 @@ int LocalReduce_Norm2_INT(int i, int weight_on, const void * const weight, CCTK_ return 0; } -#ifdef CCTK_INT1 +#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; @@ -606,22 +606,22 @@ int LocalReduce_Norm2_INT1(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_INT12 + #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 CCTK_INT14 + #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 CCTK_INT18 + #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; @@ -629,17 +629,17 @@ int LocalReduce_Norm2_INT1(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -691,7 +691,7 @@ int LocalReduce_Norm2_INT1(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -716,8 +716,8 @@ int LocalReduce_Norm2_INT1(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd8( Norm2, scalar); +#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) @@ -740,7 +740,7 @@ int LocalReduce_Norm2_INT1(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -765,9 +765,9 @@ int LocalReduce_Norm2_INT1(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); +#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) @@ -791,7 +791,7 @@ int LocalReduce_Norm2_INT1(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -816,8 +816,8 @@ int LocalReduce_Norm2_INT1(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd32( Norm2, scalar); +#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) @@ -847,7 +847,7 @@ int LocalReduce_Norm2_INT1(int i, int weight_on, const void * const weight, CCTK } #endif -#ifdef CCTK_INT2 +#ifdef HAVE_CCTK_INT2 int LocalReduce_Norm2_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; @@ -884,22 +884,22 @@ int LocalReduce_Norm2_INT2(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_INT22 + #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 CCTK_INT24 + #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 CCTK_INT28 + #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; @@ -907,17 +907,17 @@ int LocalReduce_Norm2_INT2(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -969,7 +969,7 @@ int LocalReduce_Norm2_INT2(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -994,8 +994,8 @@ int LocalReduce_Norm2_INT2(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd8( Norm2, scalar); +#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) @@ -1018,7 +1018,7 @@ int LocalReduce_Norm2_INT2(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1043,9 +1043,9 @@ int LocalReduce_Norm2_INT2(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); +#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) @@ -1069,7 +1069,7 @@ int LocalReduce_Norm2_INT2(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1094,8 +1094,8 @@ int LocalReduce_Norm2_INT2(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd32( Norm2, scalar); +#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) @@ -1125,7 +1125,7 @@ int LocalReduce_Norm2_INT2(int i, int weight_on, const void * const weight, CCTK } #endif -#ifdef CCTK_INT4 +#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; @@ -1162,22 +1162,22 @@ int LocalReduce_Norm2_INT4(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1185,17 +1185,17 @@ int LocalReduce_Norm2_INT4(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1247,7 +1247,7 @@ int LocalReduce_Norm2_INT4(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1272,8 +1272,8 @@ int LocalReduce_Norm2_INT4(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd8( Norm2, scalar); +#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) @@ -1296,7 +1296,7 @@ int LocalReduce_Norm2_INT4(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1321,9 +1321,9 @@ int LocalReduce_Norm2_INT4(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); +#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) @@ -1347,7 +1347,7 @@ int LocalReduce_Norm2_INT4(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1372,8 +1372,8 @@ int LocalReduce_Norm2_INT4(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd32( Norm2, scalar); +#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) @@ -1403,7 +1403,7 @@ int LocalReduce_Norm2_INT4(int i, int weight_on, const void * const weight, CCTK } #endif -#ifdef CCTK_INT8 +#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; @@ -1440,22 +1440,22 @@ int LocalReduce_Norm2_INT8(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1463,17 +1463,17 @@ int LocalReduce_Norm2_INT8(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1525,7 +1525,7 @@ int LocalReduce_Norm2_INT8(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1550,8 +1550,8 @@ int LocalReduce_Norm2_INT8(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd8( Norm2, scalar); +#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) @@ -1574,7 +1574,7 @@ int LocalReduce_Norm2_INT8(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1599,9 +1599,9 @@ int LocalReduce_Norm2_INT8(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); +#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) @@ -1625,7 +1625,7 @@ int LocalReduce_Norm2_INT8(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1650,8 +1650,8 @@ int LocalReduce_Norm2_INT8(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd32( Norm2, scalar); +#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) @@ -1717,22 +1717,22 @@ int LocalReduce_Norm2_REAL(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1740,17 +1740,17 @@ int LocalReduce_Norm2_REAL(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1802,7 +1802,7 @@ int LocalReduce_Norm2_REAL(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1827,8 +1827,8 @@ int LocalReduce_Norm2_REAL(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd8( Norm2, scalar); +#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) @@ -1851,7 +1851,7 @@ int LocalReduce_Norm2_REAL(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1876,9 +1876,9 @@ int LocalReduce_Norm2_REAL(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); +#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) @@ -1902,7 +1902,7 @@ int LocalReduce_Norm2_REAL(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1927,8 +1927,8 @@ int LocalReduce_Norm2_REAL(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd32( Norm2, scalar); +#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) @@ -1957,7 +1957,7 @@ int LocalReduce_Norm2_REAL(int i, int weight_on, const void * const weight, CCTK return 0; } -#ifdef CCTK_REAL4 +#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; @@ -1994,22 +1994,22 @@ int LocalReduce_Norm2_REAL4(int i, int weight_on, const void * const weight, CCT 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2017,17 +2017,17 @@ int LocalReduce_Norm2_REAL4(int i, int weight_on, const void * const weight, CCT 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2079,7 +2079,7 @@ int LocalReduce_Norm2_REAL4(int i, int weight_on, const void * const weight, CCT #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2104,8 +2104,8 @@ int LocalReduce_Norm2_REAL4(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd8( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd8( Norm2, scalar); +#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) @@ -2128,7 +2128,7 @@ int LocalReduce_Norm2_REAL4(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2153,9 +2153,9 @@ int LocalReduce_Norm2_REAL4(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); +#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) @@ -2179,7 +2179,7 @@ int LocalReduce_Norm2_REAL4(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2204,8 +2204,8 @@ int LocalReduce_Norm2_REAL4(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd32( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd32( Norm2, scalar); +#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) @@ -2235,7 +2235,7 @@ int LocalReduce_Norm2_REAL4(int i, int weight_on, const void * const weight, CCT } #endif -#ifdef CCTK_REAL8 +#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; @@ -2272,22 +2272,22 @@ int LocalReduce_Norm2_REAL8(int i, int weight_on, const void * const weight, CCT 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2295,17 +2295,17 @@ int LocalReduce_Norm2_REAL8(int i, int weight_on, const void * const weight, CCT 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2357,7 +2357,7 @@ int LocalReduce_Norm2_REAL8(int i, int weight_on, const void * const weight, CCT #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2382,8 +2382,8 @@ int LocalReduce_Norm2_REAL8(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd8( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd8( Norm2, scalar); +#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) @@ -2406,7 +2406,7 @@ int LocalReduce_Norm2_REAL8(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2431,9 +2431,9 @@ int LocalReduce_Norm2_REAL8(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); +#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) @@ -2457,7 +2457,7 @@ int LocalReduce_Norm2_REAL8(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2482,8 +2482,8 @@ int LocalReduce_Norm2_REAL8(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd32( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd32( Norm2, scalar); +#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) @@ -2514,7 +2514,7 @@ int LocalReduce_Norm2_REAL8(int i, int weight_on, const void * const weight, CCT } #endif -#ifdef CCTK_REAL16 +#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; @@ -2551,22 +2551,22 @@ int LocalReduce_Norm2_REAL16(int i, int weight_on, const void * const weight, CC 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2574,17 +2574,17 @@ int LocalReduce_Norm2_REAL16(int i, int weight_on, const void * const weight, CC 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 CCTK_REAL4 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2636,7 +2636,7 @@ int LocalReduce_Norm2_REAL16(int i, int weight_on, const void * const weight, CC #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2661,8 +2661,8 @@ int LocalReduce_Norm2_REAL16(int i, int weight_on, const void * const weight, CC #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_CmplxAdd8( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd8( Norm2, scalar); +#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) @@ -2685,7 +2685,7 @@ int LocalReduce_Norm2_REAL16(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2710,9 +2710,9 @@ int LocalReduce_Norm2_REAL16(int i, int weight_on, const void * const weight, CC #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_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); +#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) @@ -2736,7 +2736,7 @@ int LocalReduce_Norm2_REAL16(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2761,8 +2761,8 @@ int LocalReduce_Norm2_REAL16(int i, int weight_on, const void * const weight, CC #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_CmplxAdd32( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd32( Norm2, scalar); +#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) @@ -2839,22 +2839,22 @@ int LocalReduce_Norm2_COMPLEX(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2862,17 +2862,17 @@ int LocalReduce_Norm2_COMPLEX(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2925,7 +2925,7 @@ int LocalReduce_Norm2_COMPLEX(int i, int weight_on, const void * const weight, C #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2940,8 +2940,8 @@ int LocalReduce_Norm2_COMPLEX(int i, int weight_on, const void * const weight, C #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_CmplxMul8(scalar,scalar);Norm2 = CCTK_CmplxAdd8( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul8(scalar,scalar);Norm2 = CCTK_CmplxAdd8( Norm2, scalar); +#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) @@ -2975,7 +2975,7 @@ int LocalReduce_Norm2_COMPLEX(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2990,8 +2990,8 @@ int LocalReduce_Norm2_COMPLEX(int i, int weight_on, const void * const weight, C #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_CmplxMul16(scalar,scalar); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul16(scalar,scalar); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); +#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) @@ -3026,7 +3026,7 @@ int LocalReduce_Norm2_COMPLEX(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3041,8 +3041,8 @@ int LocalReduce_Norm2_COMPLEX(int i, int weight_on, const void * const weight, C #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_CmplxMul32(scalar,scalar); Norm2 = CCTK_CmplxAdd32( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar,scalar); Norm2 = CCTK_CmplxAdd32( Norm2, scalar); +#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) @@ -3083,7 +3083,7 @@ int LocalReduce_Norm2_COMPLEX(int i, int weight_on, const void * const weight, C } -#ifdef CCTK_COMPLEX8 +#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; @@ -3131,22 +3131,22 @@ int LocalReduce_Norm2_COMPLEX8(int i, int weight_on, const void * const weight, 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -3154,17 +3154,17 @@ int LocalReduce_Norm2_COMPLEX8(int i, int weight_on, const void * const weight, 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3217,7 +3217,7 @@ int LocalReduce_Norm2_COMPLEX8(int i, int weight_on, const void * const weight, #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3232,8 +3232,8 @@ int LocalReduce_Norm2_COMPLEX8(int i, int weight_on, const void * const weight, #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_CmplxMul8(scalar,scalar);Norm2 = CCTK_CmplxAdd8( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul8(scalar,scalar);Norm2 = CCTK_CmplxAdd8( Norm2, scalar); +#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) @@ -3267,7 +3267,7 @@ int LocalReduce_Norm2_COMPLEX8(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3282,8 +3282,8 @@ int LocalReduce_Norm2_COMPLEX8(int i, int weight_on, const void * const weight, #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_CmplxMul16(scalar,scalar); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul16(scalar,scalar); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); +#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) @@ -3318,7 +3318,7 @@ int LocalReduce_Norm2_COMPLEX8(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3333,8 +3333,8 @@ int LocalReduce_Norm2_COMPLEX8(int i, int weight_on, const void * const weight, #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_CmplxMul32(scalar,scalar); Norm2 = CCTK_CmplxAdd32( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar,scalar); Norm2 = CCTK_CmplxAdd32( Norm2, scalar); +#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) @@ -3375,7 +3375,7 @@ int LocalReduce_Norm2_COMPLEX8(int i, int weight_on, const void * const weight, } #endif -#ifdef CCTK_COMPLEX16 +#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; @@ -3423,22 +3423,22 @@ int LocalReduce_Norm2_COMPLEX16(int i, int weight_on, const void * const weight, 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -3446,17 +3446,17 @@ int LocalReduce_Norm2_COMPLEX16(int i, int weight_on, const void * const weight, 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3509,7 +3509,7 @@ int LocalReduce_Norm2_COMPLEX16(int i, int weight_on, const void * const weight, #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3524,8 +3524,8 @@ int LocalReduce_Norm2_COMPLEX16(int i, int weight_on, const void * const weight, #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_CmplxMul8(scalar,scalar);Norm2 = CCTK_CmplxAdd8( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul8(scalar,scalar);Norm2 = CCTK_CmplxAdd8( Norm2, scalar); +#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) @@ -3559,7 +3559,7 @@ int LocalReduce_Norm2_COMPLEX16(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3574,8 +3574,8 @@ int LocalReduce_Norm2_COMPLEX16(int i, int weight_on, const void * const weight, #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_CmplxMul16(scalar,scalar); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul16(scalar,scalar); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); +#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) @@ -3610,7 +3610,7 @@ int LocalReduce_Norm2_COMPLEX16(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3625,8 +3625,8 @@ int LocalReduce_Norm2_COMPLEX16(int i, int weight_on, const void * const weight, #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_CmplxMul32(scalar,scalar); Norm2 = CCTK_CmplxAdd32( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar,scalar); Norm2 = CCTK_CmplxAdd32( Norm2, scalar); +#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) @@ -3667,7 +3667,7 @@ int LocalReduce_Norm2_COMPLEX16(int i, int weight_on, const void * const weight, } #endif -#ifdef CCTK_COMPLEX32 +#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; @@ -3710,27 +3710,27 @@ 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_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -3738,17 +3738,17 @@ int LocalReduce_Norm2_COMPLEX32(int i, int weight_on, const void * const weight, 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3801,7 +3801,7 @@ int LocalReduce_Norm2_COMPLEX32(int i, int weight_on, const void * const weight, #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3816,8 +3816,8 @@ int LocalReduce_Norm2_COMPLEX32(int i, int weight_on, const void * const weight, #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_CmplxMul8(scalar,scalar);Norm2 = CCTK_CmplxAdd8( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul8(scalar,scalar);Norm2 = CCTK_CmplxAdd8( Norm2, scalar); +#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) @@ -3851,7 +3851,7 @@ int LocalReduce_Norm2_COMPLEX32(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3866,8 +3866,8 @@ int LocalReduce_Norm2_COMPLEX32(int i, int weight_on, const void * const weight, #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_CmplxMul16(scalar,scalar); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul16(scalar,scalar); Norm2 = CCTK_CmplxAdd16( Norm2, scalar); +#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) @@ -3902,7 +3902,7 @@ int LocalReduce_Norm2_COMPLEX32(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3917,8 +3917,8 @@ int LocalReduce_Norm2_COMPLEX32(int i, int weight_on, const void * const weight, #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_CmplxMul32(scalar,scalar); Norm2 = CCTK_CmplxAdd32( Norm2, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar,scalar); Norm2 = CCTK_CmplxAdd32( Norm2, scalar); +#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) diff --git a/src/Norm2_Functions.h b/src/Norm2_Functions.h index c807fb8..f1bcd63 100644 --- a/src/Norm2_Functions.h +++ b/src/Norm2_Functions.h @@ -22,47 +22,47 @@ int LocalReduce_Norm2_BYTE(int i, int weight_on, const void * const weight, CCTK int LocalReduce_Norm2_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 CCTK_INT1 +#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); #endif -#ifdef CCTK_INT2 +#ifdef HAVE_CCTK_INT2 int LocalReduce_Norm2_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); #endif -#ifdef CCTK_INT4 +#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); #endif -#ifdef CCTK_INT8 +#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); #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); -#ifdef CCTK_REAL4 +#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); #endif -#ifdef CCTK_REAL8 +#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); #endif -#ifdef CCTK_REAL16 +#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); #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); -#ifdef CCTK_COMPLEX8 +#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); #endif -#ifdef CCTK_COMPLEX16 +#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); #endif -#ifdef CCTK_COMPLEX32 +#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); #endif diff --git a/src/Norm3Functions.c b/src/Norm3Functions.c index deacf8d..7fa65aa 100644 --- a/src/Norm3Functions.c +++ b/src/Norm3Functions.c @@ -59,22 +59,22 @@ int LocalReduce_Norm3_BYTE(int i, int weight_on, const void * const weight, CCTK case CCTK_VARIABLE_INT: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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; @@ -82,17 +82,17 @@ int LocalReduce_Norm3_BYTE(int i, int weight_on, const void * const weight, CCTK case CCTK_VARIABLE_REAL: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: 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; @@ -145,7 +145,7 @@ int LocalReduce_Norm3_BYTE(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -170,8 +170,8 @@ int LocalReduce_Norm3_BYTE(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( 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_CmplxAdd8( Norm3, scalar); +#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) @@ -194,7 +194,7 @@ int LocalReduce_Norm3_BYTE(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -219,8 +219,8 @@ int LocalReduce_Norm3_BYTE(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( 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_CmplxAdd16( Norm3, scalar); +#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) @@ -244,7 +244,7 @@ int LocalReduce_Norm3_BYTE(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -269,8 +269,8 @@ int LocalReduce_Norm3_BYTE(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( 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_CmplxAdd32( Norm3, scalar); +#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) @@ -335,22 +335,22 @@ int LocalReduce_Norm3_INT(int i, int weight_on, const void * const weight, CCTK_ 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -358,17 +358,17 @@ int LocalReduce_Norm3_INT(int i, int weight_on, const void * const weight, CCTK_ 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 CCTK_REAL4 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -420,7 +420,7 @@ int LocalReduce_Norm3_INT(int i, int weight_on, const void * const weight, CCTK_ #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -445,8 +445,8 @@ int LocalReduce_Norm3_INT(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd8( 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_CmplxAdd8( Norm3, scalar); +#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) @@ -469,7 +469,7 @@ int LocalReduce_Norm3_INT(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -494,8 +494,8 @@ int LocalReduce_Norm3_INT(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd16( 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_CmplxAdd16( Norm3, scalar); +#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) @@ -518,7 +518,7 @@ int LocalReduce_Norm3_INT(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -543,8 +543,8 @@ int LocalReduce_Norm3_INT(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd32( 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_CmplxAdd32( Norm3, scalar); +#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) @@ -572,7 +572,7 @@ int LocalReduce_Norm3_INT(int i, int weight_on, const void * const weight, CCTK_ return 0; } -#ifdef CCTK_INT1 +#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; @@ -609,22 +609,22 @@ int LocalReduce_Norm3_INT1(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_INT12 + #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 CCTK_INT14 + #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 CCTK_INT18 + #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; @@ -632,17 +632,17 @@ int LocalReduce_Norm3_INT1(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -694,7 +694,7 @@ int LocalReduce_Norm3_INT1(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -719,8 +719,8 @@ int LocalReduce_Norm3_INT1(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( 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_CmplxAdd8( Norm3, scalar); +#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) @@ -743,7 +743,7 @@ int LocalReduce_Norm3_INT1(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -768,8 +768,8 @@ int LocalReduce_Norm3_INT1(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( 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_CmplxAdd16( Norm3, scalar); +#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) @@ -793,7 +793,7 @@ int LocalReduce_Norm3_INT1(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -818,8 +818,8 @@ int LocalReduce_Norm3_INT1(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( 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_CmplxAdd32( Norm3, scalar); +#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) @@ -849,7 +849,7 @@ int LocalReduce_Norm3_INT1(int i, int weight_on, const void * const weight, CCTK } #endif -#ifdef CCTK_INT2 +#ifdef HAVE_CCTK_INT2 int LocalReduce_Norm3_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; @@ -886,22 +886,22 @@ int LocalReduce_Norm3_INT2(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_INT22 + #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 CCTK_INT24 + #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 CCTK_INT28 + #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; @@ -909,17 +909,17 @@ int LocalReduce_Norm3_INT2(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -971,7 +971,7 @@ int LocalReduce_Norm3_INT2(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -996,8 +996,8 @@ int LocalReduce_Norm3_INT2(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( 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_CmplxAdd8( Norm3, scalar); +#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) @@ -1020,7 +1020,7 @@ int LocalReduce_Norm3_INT2(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1045,8 +1045,8 @@ int LocalReduce_Norm3_INT2(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( 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_CmplxAdd16( Norm3, scalar); +#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) @@ -1070,7 +1070,7 @@ int LocalReduce_Norm3_INT2(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1095,8 +1095,8 @@ int LocalReduce_Norm3_INT2(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( 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_CmplxAdd32( Norm3, scalar); +#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) @@ -1126,7 +1126,7 @@ int LocalReduce_Norm3_INT2(int i, int weight_on, const void * const weight, CCTK } #endif -#ifdef CCTK_INT4 +#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; @@ -1163,22 +1163,22 @@ int LocalReduce_Norm3_INT4(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1186,17 +1186,17 @@ int LocalReduce_Norm3_INT4(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1248,7 +1248,7 @@ int LocalReduce_Norm3_INT4(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1273,8 +1273,8 @@ int LocalReduce_Norm3_INT4(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( 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_CmplxAdd8( Norm3, scalar); +#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) @@ -1297,7 +1297,7 @@ int LocalReduce_Norm3_INT4(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1322,8 +1322,8 @@ int LocalReduce_Norm3_INT4(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( 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_CmplxAdd16( Norm3, scalar); +#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) @@ -1347,7 +1347,7 @@ int LocalReduce_Norm3_INT4(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1372,8 +1372,8 @@ int LocalReduce_Norm3_INT4(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( 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_CmplxAdd32( Norm3, scalar); +#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) @@ -1403,7 +1403,7 @@ int LocalReduce_Norm3_INT4(int i, int weight_on, const void * const weight, CCTK } #endif -#ifdef CCTK_INT8 +#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; @@ -1440,22 +1440,22 @@ int LocalReduce_Norm3_INT8(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1463,17 +1463,17 @@ int LocalReduce_Norm3_INT8(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1525,7 +1525,7 @@ int LocalReduce_Norm3_INT8(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1550,8 +1550,8 @@ int LocalReduce_Norm3_INT8(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( 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_CmplxAdd8( Norm3, scalar); +#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) @@ -1574,7 +1574,7 @@ int LocalReduce_Norm3_INT8(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1599,8 +1599,8 @@ int LocalReduce_Norm3_INT8(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( 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_CmplxAdd16( Norm3, scalar); +#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) @@ -1624,7 +1624,7 @@ int LocalReduce_Norm3_INT8(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1649,8 +1649,8 @@ int LocalReduce_Norm3_INT8(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( 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_CmplxAdd32( Norm3, scalar); +#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) @@ -1716,22 +1716,22 @@ int LocalReduce_Norm3_REAL(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1739,17 +1739,17 @@ int LocalReduce_Norm3_REAL(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1801,7 +1801,7 @@ int LocalReduce_Norm3_REAL(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1826,8 +1826,8 @@ int LocalReduce_Norm3_REAL(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( 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_CmplxAdd8( Norm3, scalar); +#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) @@ -1850,7 +1850,7 @@ int LocalReduce_Norm3_REAL(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1875,8 +1875,8 @@ int LocalReduce_Norm3_REAL(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( 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_CmplxAdd16( Norm3, scalar); +#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) @@ -1900,7 +1900,7 @@ int LocalReduce_Norm3_REAL(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1925,8 +1925,8 @@ int LocalReduce_Norm3_REAL(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( 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_CmplxAdd32( Norm3, scalar); +#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) @@ -1955,7 +1955,7 @@ int LocalReduce_Norm3_REAL(int i, int weight_on, const void * const weight, CCTK return 0; } -#ifdef CCTK_REAL4 +#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; @@ -1992,22 +1992,22 @@ int LocalReduce_Norm3_REAL4(int i, int weight_on, const void * const weight, CCT 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2015,17 +2015,17 @@ int LocalReduce_Norm3_REAL4(int i, int weight_on, const void * const weight, CCT 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2077,7 +2077,7 @@ int LocalReduce_Norm3_REAL4(int i, int weight_on, const void * const weight, CCT #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2102,8 +2102,8 @@ int LocalReduce_Norm3_REAL4(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd8( 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_CmplxAdd8( Norm3, scalar); +#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) @@ -2126,7 +2126,7 @@ int LocalReduce_Norm3_REAL4(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2151,8 +2151,8 @@ int LocalReduce_Norm3_REAL4(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd16( 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_CmplxAdd16( Norm3, scalar); +#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) @@ -2176,7 +2176,7 @@ int LocalReduce_Norm3_REAL4(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2201,8 +2201,8 @@ int LocalReduce_Norm3_REAL4(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd32( 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_CmplxAdd32( Norm3, scalar); +#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) @@ -2232,7 +2232,7 @@ int LocalReduce_Norm3_REAL4(int i, int weight_on, const void * const weight, CCT } #endif -#ifdef CCTK_REAL8 +#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; @@ -2269,22 +2269,22 @@ int LocalReduce_Norm3_REAL8(int i, int weight_on, const void * const weight, CCT 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2292,17 +2292,17 @@ int LocalReduce_Norm3_REAL8(int i, int weight_on, const void * const weight, CCT 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2354,7 +2354,7 @@ int LocalReduce_Norm3_REAL8(int i, int weight_on, const void * const weight, CCT #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2379,8 +2379,8 @@ int LocalReduce_Norm3_REAL8(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd8( 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_CmplxAdd8( Norm3, scalar); +#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) @@ -2403,7 +2403,7 @@ int LocalReduce_Norm3_REAL8(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2428,8 +2428,8 @@ int LocalReduce_Norm3_REAL8(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd16( 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_CmplxAdd16( Norm3, scalar); +#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) @@ -2453,7 +2453,7 @@ int LocalReduce_Norm3_REAL8(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2478,8 +2478,8 @@ int LocalReduce_Norm3_REAL8(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd32( 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_CmplxAdd32( Norm3, scalar); +#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) @@ -2510,7 +2510,7 @@ int LocalReduce_Norm3_REAL8(int i, int weight_on, const void * const weight, CCT } #endif -#ifdef CCTK_REAL16 +#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; @@ -2547,22 +2547,22 @@ int LocalReduce_Norm3_REAL16(int i, int weight_on, const void * const weight, CC 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2570,17 +2570,17 @@ int LocalReduce_Norm3_REAL16(int i, int weight_on, const void * const weight, CC 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 CCTK_REAL4 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2632,7 +2632,7 @@ int LocalReduce_Norm3_REAL16(int i, int weight_on, const void * const weight, CC #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2657,8 +2657,8 @@ int LocalReduce_Norm3_REAL16(int i, int weight_on, const void * const weight, CC #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_CmplxAdd8( 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_CmplxAdd8( Norm3, scalar); +#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) @@ -2681,7 +2681,7 @@ int LocalReduce_Norm3_REAL16(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2706,8 +2706,8 @@ int LocalReduce_Norm3_REAL16(int i, int weight_on, const void * const weight, CC #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_CmplxAdd16( 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_CmplxAdd16( Norm3, scalar); +#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) @@ -2731,7 +2731,7 @@ int LocalReduce_Norm3_REAL16(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2756,8 +2756,8 @@ int LocalReduce_Norm3_REAL16(int i, int weight_on, const void * const weight, CC #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_CmplxAdd32( 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_CmplxAdd32( Norm3, scalar); +#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) @@ -2834,22 +2834,22 @@ int LocalReduce_Norm3_COMPLEX(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2857,17 +2857,17 @@ int LocalReduce_Norm3_COMPLEX(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2920,7 +2920,7 @@ int LocalReduce_Norm3_COMPLEX(int i, int weight_on, const void * const weight, C #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2935,8 +2935,8 @@ int LocalReduce_Norm3_COMPLEX(int i, int weight_on, const void * const weight, C #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_CmplxMul8(scalar, CCTK_CmplxMul8(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd8( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul8(scalar, CCTK_CmplxMul8(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd8( Norm3, scalar); +#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) @@ -2970,7 +2970,7 @@ int LocalReduce_Norm3_COMPLEX(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2985,8 +2985,8 @@ int LocalReduce_Norm3_COMPLEX(int i, int weight_on, const void * const weight, C #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_CmplxMul16(scalar, CCTK_CmplxMul16(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd16( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul16(scalar, CCTK_CmplxMul16(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd16( Norm3, scalar); +#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) @@ -3021,7 +3021,7 @@ int LocalReduce_Norm3_COMPLEX(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3036,8 +3036,8 @@ int LocalReduce_Norm3_COMPLEX(int i, int weight_on, const void * const weight, C #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_CmplxMul32(scalar, CCTK_CmplxMul32(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd32( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar, CCTK_CmplxMul32(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd32( Norm3, scalar); +#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) @@ -3078,7 +3078,7 @@ int LocalReduce_Norm3_COMPLEX(int i, int weight_on, const void * const weight, C } -#ifdef CCTK_COMPLEX8 +#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; @@ -3126,22 +3126,22 @@ int LocalReduce_Norm3_COMPLEX8(int i, int weight_on, const void * const weight, 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -3149,17 +3149,17 @@ int LocalReduce_Norm3_COMPLEX8(int i, int weight_on, const void * const weight, 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3212,7 +3212,7 @@ int LocalReduce_Norm3_COMPLEX8(int i, int weight_on, const void * const weight, #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3227,8 +3227,8 @@ int LocalReduce_Norm3_COMPLEX8(int i, int weight_on, const void * const weight, #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_CmplxMul8(scalar, CCTK_CmplxMul8(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd8( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul8(scalar, CCTK_CmplxMul8(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd8( Norm3, scalar); +#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) @@ -3262,7 +3262,7 @@ int LocalReduce_Norm3_COMPLEX8(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3277,8 +3277,8 @@ int LocalReduce_Norm3_COMPLEX8(int i, int weight_on, const void * const weight, #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_CmplxMul16(scalar, CCTK_CmplxMul16(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd16( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul16(scalar, CCTK_CmplxMul16(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd16( Norm3, scalar); +#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) @@ -3313,7 +3313,7 @@ int LocalReduce_Norm3_COMPLEX8(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3328,8 +3328,8 @@ int LocalReduce_Norm3_COMPLEX8(int i, int weight_on, const void * const weight, #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_CmplxMul32(scalar, CCTK_CmplxMul32(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd32( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar, CCTK_CmplxMul32(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd32( Norm3, scalar); +#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) @@ -3370,7 +3370,7 @@ int LocalReduce_Norm3_COMPLEX8(int i, int weight_on, const void * const weight, } #endif -#ifdef CCTK_COMPLEX16 +#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; @@ -3418,22 +3418,22 @@ int LocalReduce_Norm3_COMPLEX16(int i, int weight_on, const void * const weight, 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -3441,17 +3441,17 @@ int LocalReduce_Norm3_COMPLEX16(int i, int weight_on, const void * const weight, 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3504,7 +3504,7 @@ int LocalReduce_Norm3_COMPLEX16(int i, int weight_on, const void * const weight, #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3519,8 +3519,8 @@ int LocalReduce_Norm3_COMPLEX16(int i, int weight_on, const void * const weight, #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_CmplxMul8(scalar, CCTK_CmplxMul8(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd8( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul8(scalar, CCTK_CmplxMul8(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd8( Norm3, scalar); +#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) @@ -3554,7 +3554,7 @@ int LocalReduce_Norm3_COMPLEX16(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3569,8 +3569,8 @@ int LocalReduce_Norm3_COMPLEX16(int i, int weight_on, const void * const weight, #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_CmplxMul16(scalar, CCTK_CmplxMul16(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd16( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul16(scalar, CCTK_CmplxMul16(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd16( Norm3, scalar); +#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) @@ -3605,7 +3605,7 @@ int LocalReduce_Norm3_COMPLEX16(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3620,8 +3620,8 @@ int LocalReduce_Norm3_COMPLEX16(int i, int weight_on, const void * const weight, #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_CmplxMul32(scalar, CCTK_CmplxMul32(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd32( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar, CCTK_CmplxMul32(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd32( Norm3, scalar); +#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) @@ -3662,7 +3662,7 @@ int LocalReduce_Norm3_COMPLEX16(int i, int weight_on, const void * const weight, } #endif -#ifdef CCTK_COMPLEX32 +#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; @@ -3705,27 +3705,27 @@ 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_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -3733,17 +3733,17 @@ int LocalReduce_Norm3_COMPLEX32(int i, int weight_on, const void * const weight, 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3796,7 +3796,7 @@ int LocalReduce_Norm3_COMPLEX32(int i, int weight_on, const void * const weight, #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3811,8 +3811,8 @@ int LocalReduce_Norm3_COMPLEX32(int i, int weight_on, const void * const weight, #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_CmplxMul8(scalar, CCTK_CmplxMul8(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd8( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul8(scalar, CCTK_CmplxMul8(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd8( Norm3, scalar); +#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) @@ -3846,7 +3846,7 @@ int LocalReduce_Norm3_COMPLEX32(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3861,8 +3861,8 @@ int LocalReduce_Norm3_COMPLEX32(int i, int weight_on, const void * const weight, #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_CmplxMul16(scalar, CCTK_CmplxMul16(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd16( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul16(scalar, CCTK_CmplxMul16(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd16( Norm3, scalar); +#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) @@ -3897,7 +3897,7 @@ int LocalReduce_Norm3_COMPLEX32(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3912,8 +3912,8 @@ int LocalReduce_Norm3_COMPLEX32(int i, int weight_on, const void * const weight, #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_CmplxMul32(scalar, CCTK_CmplxMul32(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd32( Norm3, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar, CCTK_CmplxMul32(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im); Norm3 = CCTK_CmplxAdd32( Norm3, scalar); +#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) diff --git a/src/Norm3_Functions.h b/src/Norm3_Functions.h index f0cfd7e..2d1a610 100644 --- a/src/Norm3_Functions.h +++ b/src/Norm3_Functions.h @@ -22,47 +22,47 @@ int LocalReduce_Norm3_BYTE(int i, int weight_on, const void * const weight, CCTK int LocalReduce_Norm3_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 CCTK_INT1 +#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); #endif -#ifdef CCTK_INT2 +#ifdef HAVE_CCTK_INT2 int LocalReduce_Norm3_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); #endif -#ifdef CCTK_INT4 +#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); #endif -#ifdef CCTK_INT8 +#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); #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); -#ifdef CCTK_REAL4 +#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); #endif -#ifdef CCTK_REAL8 +#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); #endif -#ifdef CCTK_REAL16 +#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); #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); -#ifdef CCTK_COMPLEX8 +#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); #endif -#ifdef CCTK_COMPLEX16 +#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); #endif -#ifdef CCTK_COMPLEX32 +#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); #endif diff --git a/src/Norm4Functions.c b/src/Norm4Functions.c index 795bd23..33f0dda 100644 --- a/src/Norm4Functions.c +++ b/src/Norm4Functions.c @@ -54,22 +54,22 @@ int LocalReduce_Norm4_BYTE(int i, int weight_on, const void * const weight, CCTK case CCTK_VARIABLE_INT: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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; @@ -77,17 +77,17 @@ int LocalReduce_Norm4_BYTE(int i, int weight_on, const void * const weight, CCTK case CCTK_VARIABLE_REAL: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: 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; @@ -140,7 +140,7 @@ int LocalReduce_Norm4_BYTE(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -165,8 +165,8 @@ int LocalReduce_Norm4_BYTE(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd8( Norm4, scalar); +#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) @@ -189,7 +189,7 @@ int LocalReduce_Norm4_BYTE(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -214,8 +214,8 @@ int LocalReduce_Norm4_BYTE(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd16( Norm4, scalar); +#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) @@ -239,7 +239,7 @@ int LocalReduce_Norm4_BYTE(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -264,8 +264,8 @@ int LocalReduce_Norm4_BYTE(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd32( Norm4, scalar); +#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) @@ -330,22 +330,22 @@ int LocalReduce_Norm4_INT(int i, int weight_on, const void * const weight, CCTK_ 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -353,17 +353,17 @@ int LocalReduce_Norm4_INT(int i, int weight_on, const void * const weight, CCTK_ 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 CCTK_REAL4 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -415,7 +415,7 @@ int LocalReduce_Norm4_INT(int i, int weight_on, const void * const weight, CCTK_ #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -440,8 +440,8 @@ int LocalReduce_Norm4_INT(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd8( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd8( Norm4, scalar); +#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) @@ -464,7 +464,7 @@ int LocalReduce_Norm4_INT(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -489,8 +489,8 @@ int LocalReduce_Norm4_INT(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd16( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd16( Norm4, scalar); +#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) @@ -513,7 +513,7 @@ int LocalReduce_Norm4_INT(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -538,8 +538,8 @@ int LocalReduce_Norm4_INT(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd32( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd32( Norm4, scalar); +#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) @@ -567,7 +567,7 @@ int LocalReduce_Norm4_INT(int i, int weight_on, const void * const weight, CCTK_ return 0; } -#ifdef CCTK_INT1 +#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; @@ -604,22 +604,22 @@ int LocalReduce_Norm4_INT1(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_INT12 + #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 CCTK_INT14 + #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 CCTK_INT18 + #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; @@ -627,17 +627,17 @@ int LocalReduce_Norm4_INT1(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -689,7 +689,7 @@ int LocalReduce_Norm4_INT1(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -714,8 +714,8 @@ int LocalReduce_Norm4_INT1(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd8( Norm4, scalar); +#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) @@ -738,7 +738,7 @@ int LocalReduce_Norm4_INT1(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -763,8 +763,8 @@ int LocalReduce_Norm4_INT1(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd16( Norm4, scalar); +#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) @@ -788,7 +788,7 @@ int LocalReduce_Norm4_INT1(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -813,8 +813,8 @@ int LocalReduce_Norm4_INT1(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd32( Norm4, scalar); +#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) @@ -844,7 +844,7 @@ int LocalReduce_Norm4_INT1(int i, int weight_on, const void * const weight, CCTK } #endif -#ifdef CCTK_INT2 +#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; @@ -881,22 +881,22 @@ int LocalReduce_Norm4_INT2(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_INT22 + #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 CCTK_INT24 + #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 CCTK_INT28 + #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; @@ -904,17 +904,17 @@ int LocalReduce_Norm4_INT2(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -966,7 +966,7 @@ int LocalReduce_Norm4_INT2(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -991,8 +991,8 @@ int LocalReduce_Norm4_INT2(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd8( Norm4, scalar); +#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) @@ -1015,7 +1015,7 @@ int LocalReduce_Norm4_INT2(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1040,8 +1040,8 @@ int LocalReduce_Norm4_INT2(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd16( Norm4, scalar); +#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) @@ -1065,7 +1065,7 @@ int LocalReduce_Norm4_INT2(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1090,8 +1090,8 @@ int LocalReduce_Norm4_INT2(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd32( Norm4, scalar); +#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) @@ -1121,7 +1121,7 @@ int LocalReduce_Norm4_INT2(int i, int weight_on, const void * const weight, CCTK } #endif -#ifdef CCTK_INT4 +#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; @@ -1158,22 +1158,22 @@ int LocalReduce_Norm4_INT4(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1181,17 +1181,17 @@ int LocalReduce_Norm4_INT4(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1243,7 +1243,7 @@ int LocalReduce_Norm4_INT4(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1268,8 +1268,8 @@ int LocalReduce_Norm4_INT4(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd8( Norm4, scalar); +#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) @@ -1292,7 +1292,7 @@ int LocalReduce_Norm4_INT4(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1317,8 +1317,8 @@ int LocalReduce_Norm4_INT4(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd16( Norm4, scalar); +#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) @@ -1342,7 +1342,7 @@ int LocalReduce_Norm4_INT4(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1367,8 +1367,8 @@ int LocalReduce_Norm4_INT4(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd32( Norm4, scalar); +#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) @@ -1398,7 +1398,7 @@ int LocalReduce_Norm4_INT4(int i, int weight_on, const void * const weight, CCTK } #endif -#ifdef CCTK_INT8 +#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; @@ -1435,22 +1435,22 @@ int LocalReduce_Norm4_INT8(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1458,17 +1458,17 @@ int LocalReduce_Norm4_INT8(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1520,7 +1520,7 @@ int LocalReduce_Norm4_INT8(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1545,8 +1545,8 @@ int LocalReduce_Norm4_INT8(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd8( Norm4, scalar); +#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) @@ -1569,7 +1569,7 @@ int LocalReduce_Norm4_INT8(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1594,8 +1594,8 @@ int LocalReduce_Norm4_INT8(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd16( Norm4, scalar); +#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) @@ -1619,7 +1619,7 @@ int LocalReduce_Norm4_INT8(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1644,8 +1644,8 @@ int LocalReduce_Norm4_INT8(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd32( Norm4, scalar); +#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) @@ -1711,22 +1711,22 @@ int LocalReduce_Norm4_REAL(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1734,17 +1734,17 @@ int LocalReduce_Norm4_REAL(int i, int weight_on, const void * const weight, CCTK 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1796,7 +1796,7 @@ int LocalReduce_Norm4_REAL(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1821,8 +1821,8 @@ int LocalReduce_Norm4_REAL(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd8( Norm4, scalar); +#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) @@ -1845,7 +1845,7 @@ int LocalReduce_Norm4_REAL(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1870,8 +1870,8 @@ int LocalReduce_Norm4_REAL(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd16( Norm4, scalar); +#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) @@ -1895,7 +1895,7 @@ int LocalReduce_Norm4_REAL(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1920,8 +1920,8 @@ int LocalReduce_Norm4_REAL(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd32( Norm4, scalar); +#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) @@ -1950,7 +1950,7 @@ int LocalReduce_Norm4_REAL(int i, int weight_on, const void * const weight, CCTK return 0; } -#ifdef CCTK_REAL4 +#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; @@ -1987,22 +1987,22 @@ int LocalReduce_Norm4_REAL4(int i, int weight_on, const void * const weight, CCT 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2010,17 +2010,17 @@ int LocalReduce_Norm4_REAL4(int i, int weight_on, const void * const weight, CCT 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2072,7 +2072,7 @@ int LocalReduce_Norm4_REAL4(int i, int weight_on, const void * const weight, CCT #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2097,8 +2097,8 @@ int LocalReduce_Norm4_REAL4(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd8( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd8( Norm4, scalar); +#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) @@ -2121,7 +2121,7 @@ int LocalReduce_Norm4_REAL4(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2146,8 +2146,8 @@ int LocalReduce_Norm4_REAL4(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd16( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd16( Norm4, scalar); +#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) @@ -2171,7 +2171,7 @@ int LocalReduce_Norm4_REAL4(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2196,8 +2196,8 @@ int LocalReduce_Norm4_REAL4(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd32( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd32( Norm4, scalar); +#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) @@ -2227,7 +2227,7 @@ int LocalReduce_Norm4_REAL4(int i, int weight_on, const void * const weight, CCT } #endif -#ifdef CCTK_REAL8 +#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; @@ -2264,22 +2264,22 @@ int LocalReduce_Norm4_REAL8(int i, int weight_on, const void * const weight, CCT 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2287,17 +2287,17 @@ int LocalReduce_Norm4_REAL8(int i, int weight_on, const void * const weight, CCT 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2349,7 +2349,7 @@ int LocalReduce_Norm4_REAL8(int i, int weight_on, const void * const weight, CCT #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2374,8 +2374,8 @@ int LocalReduce_Norm4_REAL8(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd8( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd8( Norm4, scalar); +#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) @@ -2398,7 +2398,7 @@ int LocalReduce_Norm4_REAL8(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2423,8 +2423,8 @@ int LocalReduce_Norm4_REAL8(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd16( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd16( Norm4, scalar); +#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) @@ -2448,7 +2448,7 @@ int LocalReduce_Norm4_REAL8(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2473,8 +2473,8 @@ int LocalReduce_Norm4_REAL8(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd32( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd32( Norm4, scalar); +#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) @@ -2505,7 +2505,7 @@ int LocalReduce_Norm4_REAL8(int i, int weight_on, const void * const weight, CCT } #endif -#ifdef CCTK_REAL16 +#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; @@ -2542,22 +2542,22 @@ int LocalReduce_Norm4_REAL16(int i, int weight_on, const void * const weight, CC 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2565,17 +2565,17 @@ int LocalReduce_Norm4_REAL16(int i, int weight_on, const void * const weight, CC 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 CCTK_REAL4 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2627,7 +2627,7 @@ int LocalReduce_Norm4_REAL16(int i, int weight_on, const void * const weight, CC #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2652,8 +2652,8 @@ int LocalReduce_Norm4_REAL16(int i, int weight_on, const void * const weight, CC #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_CmplxAdd8( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd8( Norm4, scalar); +#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) @@ -2676,7 +2676,7 @@ int LocalReduce_Norm4_REAL16(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2701,8 +2701,8 @@ int LocalReduce_Norm4_REAL16(int i, int weight_on, const void * const weight, CC #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_CmplxAdd16( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd16( Norm4, scalar); +#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) @@ -2726,7 +2726,7 @@ int LocalReduce_Norm4_REAL16(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2751,8 +2751,8 @@ int LocalReduce_Norm4_REAL16(int i, int weight_on, const void * const weight, CC #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_CmplxAdd32( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd32( Norm4, scalar); +#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) @@ -2833,22 +2833,22 @@ int LocalReduce_Norm4_COMPLEX(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2856,17 +2856,17 @@ int LocalReduce_Norm4_COMPLEX(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2930,7 +2930,7 @@ int LocalReduce_Norm4_COMPLEX(int i, int weight_on, const void * const weight, C #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2945,8 +2945,8 @@ int LocalReduce_Norm4_COMPLEX(int i, int weight_on, const void * const weight, C #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_CmplxMul8(scalar,scalar); scalar = CCTK_CmplxMul8(scalar,scalar);Norm4 = CCTK_CmplxAdd8( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul8(scalar,scalar); scalar = CCTK_CmplxMul8(scalar,scalar);Norm4 = CCTK_CmplxAdd8( Norm4, scalar); +#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) @@ -2984,7 +2984,7 @@ int LocalReduce_Norm4_COMPLEX(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2999,8 +2999,8 @@ int LocalReduce_Norm4_COMPLEX(int i, int weight_on, const void * const weight, C #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_CmplxMul16(scalar,scalar); scalar = CCTK_CmplxMul16(scalar,scalar); Norm4 = CCTK_CmplxAdd16( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul16(scalar,scalar); scalar = CCTK_CmplxMul16(scalar,scalar); Norm4 = CCTK_CmplxAdd16( Norm4, scalar); +#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) @@ -3039,7 +3039,7 @@ int LocalReduce_Norm4_COMPLEX(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3057,8 +3057,8 @@ int LocalReduce_Norm4_COMPLEX(int i, int weight_on, const void * const weight, C #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_CmplxMul32(scalar,scalar); scalar = CCTK_CmplxMul32(scalar,scalar); Norm4 = CCTK_CmplxAdd32( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar,scalar); scalar = CCTK_CmplxMul32(scalar,scalar); Norm4 = CCTK_CmplxAdd32( Norm4, scalar); +#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) @@ -3103,7 +3103,7 @@ int LocalReduce_Norm4_COMPLEX(int i, int weight_on, const void * const weight, C } -#ifdef CCTK_COMPLEX8 +#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; @@ -3155,22 +3155,22 @@ int LocalReduce_Norm4_COMPLEX8(int i, int weight_on, const void * const weight, 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -3178,17 +3178,17 @@ int LocalReduce_Norm4_COMPLEX8(int i, int weight_on, const void * const weight, 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3245,7 +3245,7 @@ int LocalReduce_Norm4_COMPLEX8(int i, int weight_on, const void * const weight, #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3263,8 +3263,8 @@ int LocalReduce_Norm4_COMPLEX8(int i, int weight_on, const void * const weight, #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_CmplxMul8(scalar,scalar); scalar = CCTK_CmplxMul8(scalar,scalar);Norm4 = CCTK_CmplxAdd8( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul8(scalar,scalar); scalar = CCTK_CmplxMul8(scalar,scalar);Norm4 = CCTK_CmplxAdd8( Norm4, scalar); +#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) @@ -3302,7 +3302,7 @@ int LocalReduce_Norm4_COMPLEX8(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3320,8 +3320,8 @@ int LocalReduce_Norm4_COMPLEX8(int i, int weight_on, const void * const weight, #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_CmplxMul16(scalar,scalar); scalar = CCTK_CmplxMul16(scalar,scalar); Norm4 = CCTK_CmplxAdd16( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul16(scalar,scalar); scalar = CCTK_CmplxMul16(scalar,scalar); Norm4 = CCTK_CmplxAdd16( Norm4, scalar); +#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) @@ -3360,7 +3360,7 @@ int LocalReduce_Norm4_COMPLEX8(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3375,8 +3375,8 @@ int LocalReduce_Norm4_COMPLEX8(int i, int weight_on, const void * const weight, #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_CmplxMul32(scalar,scalar); scalar = CCTK_CmplxMul32(scalar,scalar); Norm4 = CCTK_CmplxAdd32( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar,scalar); scalar = CCTK_CmplxMul32(scalar,scalar); Norm4 = CCTK_CmplxAdd32( Norm4, scalar); +#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) @@ -3418,7 +3418,7 @@ int LocalReduce_Norm4_COMPLEX8(int i, int weight_on, const void * const weight, } #endif -#ifdef CCTK_COMPLEX16 +#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; @@ -3470,22 +3470,22 @@ int LocalReduce_Norm4_COMPLEX16(int i, int weight_on, const void * const weight, 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -3493,17 +3493,17 @@ int LocalReduce_Norm4_COMPLEX16(int i, int weight_on, const void * const weight, 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3560,7 +3560,7 @@ int LocalReduce_Norm4_COMPLEX16(int i, int weight_on, const void * const weight, #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3575,8 +3575,8 @@ int LocalReduce_Norm4_COMPLEX16(int i, int weight_on, const void * const weight, #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_CmplxMul8(scalar,scalar); scalar = CCTK_CmplxMul8(scalar,scalar);Norm4 = CCTK_CmplxAdd8( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul8(scalar,scalar); scalar = CCTK_CmplxMul8(scalar,scalar);Norm4 = CCTK_CmplxAdd8( Norm4, scalar); +#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) @@ -3614,7 +3614,7 @@ int LocalReduce_Norm4_COMPLEX16(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3632,8 +3632,8 @@ int LocalReduce_Norm4_COMPLEX16(int i, int weight_on, const void * const weight, #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_CmplxMul16(scalar,scalar); scalar = CCTK_CmplxMul16(scalar,scalar); Norm4 = CCTK_CmplxAdd16( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul16(scalar,scalar); scalar = CCTK_CmplxMul16(scalar,scalar); Norm4 = CCTK_CmplxAdd16( Norm4, scalar); +#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) @@ -3672,7 +3672,7 @@ int LocalReduce_Norm4_COMPLEX16(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3687,8 +3687,8 @@ int LocalReduce_Norm4_COMPLEX16(int i, int weight_on, const void * const weight, #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_CmplxMul32(scalar,scalar); scalar = CCTK_CmplxMul32(scalar,scalar); Norm4 = CCTK_CmplxAdd32( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar,scalar); scalar = CCTK_CmplxMul32(scalar,scalar); Norm4 = CCTK_CmplxAdd32( Norm4, scalar); +#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) @@ -3733,7 +3733,7 @@ int LocalReduce_Norm4_COMPLEX16(int i, int weight_on, const void * const weight, } #endif -#ifdef CCTK_COMPLEX32 +#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; @@ -3780,27 +3780,27 @@ 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_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -3808,17 +3808,17 @@ int LocalReduce_Norm4_COMPLEX32(int i, int weight_on, const void * const weight, 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3875,7 +3875,7 @@ int LocalReduce_Norm4_COMPLEX32(int i, int weight_on, const void * const weight, #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3890,8 +3890,8 @@ int LocalReduce_Norm4_COMPLEX32(int i, int weight_on, const void * const weight, #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_CmplxMul8(scalar,scalar); scalar = CCTK_CmplxMul8(scalar,scalar);Norm4 = CCTK_CmplxAdd8( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul8(scalar,scalar); scalar = CCTK_CmplxMul8(scalar,scalar);Norm4 = CCTK_CmplxAdd8( Norm4, scalar); +#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) @@ -3929,7 +3929,7 @@ int LocalReduce_Norm4_COMPLEX32(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3944,8 +3944,8 @@ int LocalReduce_Norm4_COMPLEX32(int i, int weight_on, const void * const weight, #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_CmplxMul16(scalar,scalar); scalar = CCTK_CmplxMul16(scalar,scalar); Norm4 = CCTK_CmplxAdd16( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul16(scalar,scalar); scalar = CCTK_CmplxMul16(scalar,scalar); Norm4 = CCTK_CmplxAdd16( Norm4, scalar); +#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) @@ -3984,7 +3984,7 @@ int LocalReduce_Norm4_COMPLEX32(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3999,8 +3999,8 @@ int LocalReduce_Norm4_COMPLEX32(int i, int weight_on, const void * const weight, #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_CmplxMul32(scalar,scalar); scalar = CCTK_CmplxMul32(scalar,scalar); Norm4 = CCTK_CmplxAdd32( Norm4, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar,scalar); scalar = CCTK_CmplxMul32(scalar,scalar); Norm4 = CCTK_CmplxAdd32( Norm4, scalar); +#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) diff --git a/src/Norm4_Functions.h b/src/Norm4_Functions.h index 10eb46c..09ed9ad 100644 --- a/src/Norm4_Functions.h +++ b/src/Norm4_Functions.h @@ -22,47 +22,47 @@ int LocalReduce_Norm4_BYTE(int i, int weight_on, const void * const weight, CCTK int LocalReduce_Norm4_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 CCTK_INT1 +#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); #endif -#ifdef CCTK_INT2 +#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); #endif -#ifdef CCTK_INT4 +#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); #endif -#ifdef CCTK_INT8 +#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); #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); -#ifdef CCTK_REAL4 +#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); #endif -#ifdef CCTK_REAL8 +#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); #endif -#ifdef CCTK_REAL16 +#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); #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); -#ifdef CCTK_COMPLEX8 +#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); #endif -#ifdef CCTK_COMPLEX16 +#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); #endif -#ifdef CCTK_COMPLEX32 +#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); #endif diff --git a/src/NormInfFunctions.c b/src/NormInfFunctions.c index 7663c3e..dee219d 100644 --- a/src/NormInfFunctions.c +++ b/src/NormInfFunctions.c @@ -58,22 +58,22 @@ int LocalReduce_NormInf_BYTE(int i, int weight_on, const void * const weight, CC case CCTK_VARIABLE_INT: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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; @@ -81,17 +81,17 @@ int LocalReduce_NormInf_BYTE(int i, int weight_on, const void * const weight, CC case CCTK_VARIABLE_REAL: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: 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; @@ -152,7 +152,7 @@ int LocalReduce_NormInf_BYTE(int i, int weight_on, const void * const weight, CC #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -181,7 +181,8 @@ int LocalReduce_NormInf_BYTE(int i, int weight_on, const void * const weight, CC #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -208,7 +209,7 @@ int LocalReduce_NormInf_BYTE(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -237,7 +238,8 @@ int LocalReduce_NormInf_BYTE(int i, int weight_on, const void * const weight, CC #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -265,7 +267,7 @@ int LocalReduce_NormInf_BYTE(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -294,7 +296,8 @@ int LocalReduce_NormInf_BYTE(int i, int weight_on, const void * const weight, CC #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -367,22 +370,22 @@ int LocalReduce_NormInf_INT(int i, int weight_on, const void * const weight, CCT 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -390,17 +393,17 @@ int LocalReduce_NormInf_INT(int i, int weight_on, const void * const weight, CCT 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 CCTK_REAL4 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -460,7 +463,7 @@ int LocalReduce_NormInf_INT(int i, int weight_on, const void * const weight, CCT #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -489,7 +492,8 @@ int LocalReduce_NormInf_INT(int i, int weight_on, const void * const weight, CCT #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -516,7 +520,7 @@ int LocalReduce_NormInf_INT(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -545,7 +549,8 @@ int LocalReduce_NormInf_INT(int i, int weight_on, const void * const weight, CCT #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -572,7 +577,7 @@ int LocalReduce_NormInf_INT(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -601,7 +606,8 @@ int LocalReduce_NormInf_INT(int i, int weight_on, const void * const weight, CCT #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -633,7 +639,7 @@ int LocalReduce_NormInf_INT(int i, int weight_on, const void * const weight, CCT return 0; } -#ifdef CCTK_INT1 +#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; @@ -674,22 +680,22 @@ int LocalReduce_NormInf_INT1(int i, int weight_on, const void * const weight, CC 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 + #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 CCTK_INT12 + #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 CCTK_INT14 + #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 CCTK_INT18 + #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; @@ -697,17 +703,17 @@ int LocalReduce_NormInf_INT1(int i, int weight_on, const void * const weight, CC 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -767,7 +773,7 @@ int LocalReduce_NormInf_INT1(int i, int weight_on, const void * const weight, CC #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -796,7 +802,8 @@ int LocalReduce_NormInf_INT1(int i, int weight_on, const void * const weight, CC #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -823,7 +830,7 @@ int LocalReduce_NormInf_INT1(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -852,7 +859,8 @@ int LocalReduce_NormInf_INT1(int i, int weight_on, const void * const weight, CC #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -880,7 +888,7 @@ int LocalReduce_NormInf_INT1(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -909,7 +917,8 @@ int LocalReduce_NormInf_INT1(int i, int weight_on, const void * const weight, CC #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -943,7 +952,7 @@ int LocalReduce_NormInf_INT1(int i, int weight_on, const void * const weight, CC } #endif -#ifdef CCTK_INT2 +#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; @@ -984,22 +993,22 @@ int LocalReduce_NormInf_INT2(int i, int weight_on, const void * const weight, CC 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 + #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 CCTK_INT22 + #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 CCTK_INT24 + #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 CCTK_INT28 + #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; @@ -1007,17 +1016,17 @@ int LocalReduce_NormInf_INT2(int i, int weight_on, const void * const weight, CC 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1077,7 +1086,7 @@ int LocalReduce_NormInf_INT2(int i, int weight_on, const void * const weight, CC #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1106,7 +1115,8 @@ int LocalReduce_NormInf_INT2(int i, int weight_on, const void * const weight, CC #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -1133,7 +1143,7 @@ int LocalReduce_NormInf_INT2(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1162,7 +1172,8 @@ int LocalReduce_NormInf_INT2(int i, int weight_on, const void * const weight, CC #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -1190,7 +1201,7 @@ int LocalReduce_NormInf_INT2(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1219,7 +1230,8 @@ int LocalReduce_NormInf_INT2(int i, int weight_on, const void * const weight, CC #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -1253,7 +1265,7 @@ int LocalReduce_NormInf_INT2(int i, int weight_on, const void * const weight, CC } #endif -#ifdef CCTK_INT4 +#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; @@ -1294,22 +1306,22 @@ int LocalReduce_NormInf_INT4(int i, int weight_on, const void * const weight, CC 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1317,17 +1329,17 @@ int LocalReduce_NormInf_INT4(int i, int weight_on, const void * const weight, CC 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1387,7 +1399,7 @@ int LocalReduce_NormInf_INT4(int i, int weight_on, const void * const weight, CC #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1416,7 +1428,8 @@ int LocalReduce_NormInf_INT4(int i, int weight_on, const void * const weight, CC #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -1443,7 +1456,7 @@ int LocalReduce_NormInf_INT4(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1472,7 +1485,8 @@ int LocalReduce_NormInf_INT4(int i, int weight_on, const void * const weight, CC #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -1500,7 +1514,7 @@ int LocalReduce_NormInf_INT4(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1529,7 +1543,8 @@ int LocalReduce_NormInf_INT4(int i, int weight_on, const void * const weight, CC #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -1563,7 +1578,7 @@ int LocalReduce_NormInf_INT4(int i, int weight_on, const void * const weight, CC } #endif -#ifdef CCTK_INT8 +#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; @@ -1604,22 +1619,22 @@ int LocalReduce_NormInf_INT8(int i, int weight_on, const void * const weight, CC 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1627,17 +1642,17 @@ int LocalReduce_NormInf_INT8(int i, int weight_on, const void * const weight, CC 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1697,7 +1712,7 @@ int LocalReduce_NormInf_INT8(int i, int weight_on, const void * const weight, CC #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1726,7 +1741,8 @@ int LocalReduce_NormInf_INT8(int i, int weight_on, const void * const weight, CC #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -1753,7 +1769,7 @@ int LocalReduce_NormInf_INT8(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1782,7 +1798,8 @@ int LocalReduce_NormInf_INT8(int i, int weight_on, const void * const weight, CC #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -1810,7 +1827,7 @@ int LocalReduce_NormInf_INT8(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1839,7 +1856,8 @@ int LocalReduce_NormInf_INT8(int i, int weight_on, const void * const weight, CC #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -1913,22 +1931,22 @@ int LocalReduce_NormInf_REAL(int i, int weight_on, const void * const weight, CC 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1936,17 +1954,17 @@ int LocalReduce_NormInf_REAL(int i, int weight_on, const void * const weight, CC 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2006,7 +2024,7 @@ int LocalReduce_NormInf_REAL(int i, int weight_on, const void * const weight, CC #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2035,7 +2053,8 @@ int LocalReduce_NormInf_REAL(int i, int weight_on, const void * const weight, CC #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -2062,7 +2081,7 @@ int LocalReduce_NormInf_REAL(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2091,7 +2110,8 @@ int LocalReduce_NormInf_REAL(int i, int weight_on, const void * const weight, CC #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -2119,7 +2139,7 @@ int LocalReduce_NormInf_REAL(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2148,7 +2168,8 @@ int LocalReduce_NormInf_REAL(int i, int weight_on, const void * const weight, CC #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -2181,7 +2202,7 @@ int LocalReduce_NormInf_REAL(int i, int weight_on, const void * const weight, CC return 0; } -#ifdef CCTK_REAL4 +#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; @@ -2222,22 +2243,22 @@ int LocalReduce_NormInf_REAL4(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2245,17 +2266,17 @@ int LocalReduce_NormInf_REAL4(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2315,7 +2336,7 @@ int LocalReduce_NormInf_REAL4(int i, int weight_on, const void * const weight, C #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2344,7 +2365,8 @@ int LocalReduce_NormInf_REAL4(int i, int weight_on, const void * const weight, C #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -2371,7 +2393,7 @@ int LocalReduce_NormInf_REAL4(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2400,7 +2422,8 @@ int LocalReduce_NormInf_REAL4(int i, int weight_on, const void * const weight, C #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -2428,7 +2451,7 @@ int LocalReduce_NormInf_REAL4(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2457,7 +2480,8 @@ int LocalReduce_NormInf_REAL4(int i, int weight_on, const void * const weight, C #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -2491,7 +2515,7 @@ int LocalReduce_NormInf_REAL4(int i, int weight_on, const void * const weight, C } #endif -#ifdef CCTK_REAL8 +#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; @@ -2532,22 +2556,22 @@ int LocalReduce_NormInf_REAL8(int i, int weight_on, const void * const weight, C 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2555,17 +2579,17 @@ int LocalReduce_NormInf_REAL8(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2625,7 +2649,7 @@ int LocalReduce_NormInf_REAL8(int i, int weight_on, const void * const weight, C #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2654,7 +2678,8 @@ int LocalReduce_NormInf_REAL8(int i, int weight_on, const void * const weight, C #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -2681,7 +2706,7 @@ int LocalReduce_NormInf_REAL8(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2710,7 +2735,8 @@ int LocalReduce_NormInf_REAL8(int i, int weight_on, const void * const weight, C #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -2738,7 +2764,7 @@ int LocalReduce_NormInf_REAL8(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2767,7 +2793,8 @@ int LocalReduce_NormInf_REAL8(int i, int weight_on, const void * const weight, C #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -2802,7 +2829,7 @@ int LocalReduce_NormInf_REAL8(int i, int weight_on, const void * const weight, C } #endif -#ifdef CCTK_REAL16 +#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; @@ -2843,22 +2870,22 @@ int LocalReduce_NormInf_REAL16(int i, int weight_on, const void * const weight, 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2866,17 +2893,17 @@ int LocalReduce_NormInf_REAL16(int i, int weight_on, const void * const weight, 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 CCTK_REAL4 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2936,7 +2963,7 @@ int LocalReduce_NormInf_REAL16(int i, int weight_on, const void * const weight, #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2965,7 +2992,8 @@ int LocalReduce_NormInf_REAL16(int i, int weight_on, const void * const weight, #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -2992,7 +3020,7 @@ int LocalReduce_NormInf_REAL16(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3021,7 +3049,8 @@ int LocalReduce_NormInf_REAL16(int i, int weight_on, const void * const weight, #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -3049,7 +3078,7 @@ int LocalReduce_NormInf_REAL16(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3078,7 +3107,8 @@ int LocalReduce_NormInf_REAL16(int i, int weight_on, const void * const weight, #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \ inval.Re = (CCTK_REAL16) typed_vdata[sum_indices]; #endif -#define REDUCTION_OPERATION(NormInf, scalar) NormInf = MAX( (NormInf).Re, ABS((scalar).Re)); +#define REDUCTION_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) @@ -3155,22 +3185,22 @@ int LocalReduce_NormInf_COMPLEX(int i, int weight_on, const void * const weight, 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -3178,17 +3208,17 @@ int LocalReduce_NormInf_COMPLEX(int i, int weight_on, const void * const weight, 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3241,7 +3271,7 @@ int LocalReduce_NormInf_COMPLEX(int i, int weight_on, const void * const weight, #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3291,7 +3321,7 @@ int LocalReduce_NormInf_COMPLEX(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3342,7 +3372,7 @@ int LocalReduce_NormInf_COMPLEX(int i, int weight_on, const void * const weight, break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3399,7 +3429,7 @@ int LocalReduce_NormInf_COMPLEX(int i, int weight_on, const void * const weight, } -#ifdef CCTK_COMPLEX8 +#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; @@ -3415,19 +3445,9 @@ int LocalReduce_NormInf_COMPLEX8(int i, int weight_on, const void * const weight #undef REDUCTION_INITIAL #undef EXTRA_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)); @@ -3443,22 +3463,22 @@ int LocalReduce_NormInf_COMPLEX8(int i, int weight_on, const void * const weight 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -3466,17 +3486,17 @@ int LocalReduce_NormInf_COMPLEX8(int i, int weight_on, const void * const weight 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3509,19 +3529,9 @@ int LocalReduce_NormInf_COMPLEX8(int i, int weight_on, const void * const weight #undef REDUCTION_INITIAL #undef EXTRA_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)); @@ -3529,7 +3539,7 @@ int LocalReduce_NormInf_COMPLEX8(int i, int weight_on, const void * const weight #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3579,7 +3589,7 @@ int LocalReduce_NormInf_COMPLEX8(int i, int weight_on, const void * const weight break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3630,7 +3640,7 @@ int LocalReduce_NormInf_COMPLEX8(int i, int weight_on, const void * const weight break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3687,7 +3697,7 @@ int LocalReduce_NormInf_COMPLEX8(int i, int weight_on, const void * const weight } #endif -#ifdef CCTK_COMPLEX16 +#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; @@ -3731,22 +3741,22 @@ int LocalReduce_NormInf_COMPLEX16(int i, int weight_on, const void * const weigh 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -3754,17 +3764,17 @@ int LocalReduce_NormInf_COMPLEX16(int i, int weight_on, const void * const weigh 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3817,7 +3827,7 @@ int LocalReduce_NormInf_COMPLEX16(int i, int weight_on, const void * const weigh #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3867,7 +3877,7 @@ int LocalReduce_NormInf_COMPLEX16(int i, int weight_on, const void * const weigh break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3918,7 +3928,7 @@ int LocalReduce_NormInf_COMPLEX16(int i, int weight_on, const void * const weigh break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3975,7 +3985,7 @@ int LocalReduce_NormInf_COMPLEX16(int i, int weight_on, const void * const weigh } #endif -#ifdef CCTK_COMPLEX32 +#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; @@ -3991,19 +4001,9 @@ int LocalReduce_NormInf_COMPLEX32(int i, int weight_on, const void * const weigh #undef REDUCTION_INITIAL #undef EXTRA_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)); @@ -4014,27 +4014,27 @@ 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_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product) + 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -4042,17 +4042,17 @@ int LocalReduce_NormInf_COMPLEX32(int i, int weight_on, const void * const weigh 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -4105,7 +4105,7 @@ int LocalReduce_NormInf_COMPLEX32(int i, int weight_on, const void * const weigh #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -4155,7 +4155,7 @@ int LocalReduce_NormInf_COMPLEX32(int i, int weight_on, const void * const weigh break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -4206,7 +4206,7 @@ int LocalReduce_NormInf_COMPLEX32(int i, int weight_on, const void * const weigh break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION diff --git a/src/NormInf_Functions.h b/src/NormInf_Functions.h index bb386d6..4e77f4d 100644 --- a/src/NormInf_Functions.h +++ b/src/NormInf_Functions.h @@ -22,47 +22,47 @@ int LocalReduce_NormInf_BYTE(int i, int weight_on, const void * const weight, CC 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 CCTK_INT1 +#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); #endif -#ifdef CCTK_INT2 +#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); #endif -#ifdef CCTK_INT4 +#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); #endif -#ifdef CCTK_INT8 +#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); #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); -#ifdef CCTK_REAL4 +#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); #endif -#ifdef CCTK_REAL8 +#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); #endif -#ifdef CCTK_REAL16 +#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); #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); -#ifdef CCTK_COMPLEX8 +#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); #endif -#ifdef CCTK_COMPLEX16 +#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); #endif -#ifdef CCTK_COMPLEX32 +#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); #endif diff --git a/src/ReductionAvg.c b/src/ReductionAvg.c index d0e39aa..bf766d1 100644 --- a/src/ReductionAvg.c +++ b/src/ReductionAvg.c @@ -252,22 +252,22 @@ static int ReductionAvg (int N_dims, int operator_handle, case CCTK_VARIABLE_INT: ierr = LocalReduce_Avg_INT(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 CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: ierr = LocalReduce_Avg_INT1(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 CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: ierr = LocalReduce_Avg_INT2(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 CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: ierr = LocalReduce_Avg_INT4(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 CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: ierr = LocalReduce_Avg_INT8(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; @@ -275,17 +275,17 @@ static int ReductionAvg (int N_dims, int operator_handle, case CCTK_VARIABLE_REAL: ierr = LocalReduce_Avg_REAL(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 CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: ierr = LocalReduce_Avg_REAL4(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 CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: ierr = LocalReduce_Avg_REAL8(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 CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: ierr = 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; @@ -293,17 +293,17 @@ static int ReductionAvg (int N_dims, int operator_handle, case CCTK_VARIABLE_COMPLEX: ierr = 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 CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: ierr = 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 CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: ierr = 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 CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: ierr = 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; @@ -341,22 +341,22 @@ static int ReductionAvg (int N_dims, int operator_handle, case CCTK_VARIABLE_INT: *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / weight_sum; break; - #ifdef CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / weight_sum; break; #endif - #ifdef CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / weight_sum; break; #endif - #ifdef CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / weight_sum; break; #endif - #ifdef CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / weight_sum; break; @@ -364,17 +364,17 @@ static int ReductionAvg (int N_dims, int operator_handle, case CCTK_VARIABLE_REAL: *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / weight_sum; break; - #ifdef CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / weight_sum; break; #endif - #ifdef CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / weight_sum; break; #endif - #ifdef CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / weight_sum; break; @@ -383,19 +383,19 @@ static int ReductionAvg (int N_dims, int operator_handle, (*( (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 CCTK_COMPLEX8 + #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 CCTK_COMPLEX16 + #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 CCTK_COMPLEX32 + #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; @@ -423,22 +423,22 @@ static int ReductionAvg (int N_dims, int operator_handle, case CCTK_VARIABLE_INT: *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / num_points; break; - #ifdef CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / num_points; break; #endif - #ifdef CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / num_points; break; #endif - #ifdef CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / num_points; break; #endif - #ifdef CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / num_points; break; @@ -446,17 +446,17 @@ static int ReductionAvg (int N_dims, int operator_handle, case CCTK_VARIABLE_REAL: *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / num_points; break; - #ifdef CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / num_points; break; #endif - #ifdef CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / num_points; break; #endif - #ifdef CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; break; @@ -465,19 +465,19 @@ static int ReductionAvg (int N_dims, int operator_handle, (*( (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 CCTK_COMPLEX8 + #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 CCTK_COMPLEX16 + #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 CCTK_COMPLEX32 + #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; diff --git a/src/ReductionCount.c b/src/ReductionCount.c index adf43bd..e9db529 100644 --- a/src/ReductionCount.c +++ b/src/ReductionCount.c @@ -252,22 +252,22 @@ static int ReductionCount (int N_dims, int operator_handle, case CCTK_VARIABLE_INT: ierr = LocalReduce_Count_INT(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 CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: ierr = LocalReduce_Count_INT1(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 CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: ierr = LocalReduce_Count_INT2(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 CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: ierr = LocalReduce_Count_INT4(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 CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: ierr = LocalReduce_Count_INT8(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; @@ -275,17 +275,17 @@ static int ReductionCount (int N_dims, int operator_handle, case CCTK_VARIABLE_REAL: ierr = LocalReduce_Count_REAL(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 CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: ierr = LocalReduce_Count_REAL4(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 CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: ierr = LocalReduce_Count_REAL8(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 CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: ierr = 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; @@ -293,17 +293,17 @@ static int ReductionCount (int N_dims, int operator_handle, case CCTK_VARIABLE_COMPLEX: ierr = 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 CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: ierr = 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 CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: ierr = 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 CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: ierr = 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; diff --git a/src/ReductionMax.c b/src/ReductionMax.c index e7143ee..a40bb73 100644 --- a/src/ReductionMax.c +++ b/src/ReductionMax.c @@ -244,22 +244,22 @@ static int ReductionMax (int N_dims, int operator_handle, case CCTK_VARIABLE_INT: ierr = LocalReduce_Max_INT(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 CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: ierr = LocalReduce_Max_INT1(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 CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: ierr = LocalReduce_Max_INT2(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 CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: ierr = LocalReduce_Max_INT4(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 CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: ierr = LocalReduce_Max_INT8(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; @@ -267,17 +267,17 @@ static int ReductionMax (int N_dims, int operator_handle, case CCTK_VARIABLE_REAL: ierr = LocalReduce_Max_REAL(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 CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: ierr = LocalReduce_Max_REAL4(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 CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: ierr = LocalReduce_Max_REAL8(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 CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: ierr = 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; @@ -285,17 +285,17 @@ static int ReductionMax (int N_dims, int operator_handle, case CCTK_VARIABLE_COMPLEX: ierr = 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 CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: ierr = 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 CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: ierr = 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 CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: ierr = 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; diff --git a/src/ReductionMin.c b/src/ReductionMin.c index 55512b2..c3a0590 100644 --- a/src/ReductionMin.c +++ b/src/ReductionMin.c @@ -253,22 +253,22 @@ static int ReductionMin (int N_dims, int operator_handle, case CCTK_VARIABLE_INT: num_points = LocalReduce_Min_INT(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 CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: num_points = LocalReduce_Min_INT1(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 CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: num_points = LocalReduce_Min_INT2(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 CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: num_points = LocalReduce_Min_INT4(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 CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: num_points = LocalReduce_Min_INT8(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; @@ -276,17 +276,17 @@ static int ReductionMin (int N_dims, int operator_handle, case CCTK_VARIABLE_REAL: num_points = LocalReduce_Min_REAL(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 CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: num_points = LocalReduce_Min_REAL4(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 CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: num_points = LocalReduce_Min_REAL8(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 CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: 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; @@ -294,17 +294,17 @@ static int ReductionMin (int N_dims, int operator_handle, 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 CCTK_COMPLEX8 + #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 CCTK_COMPLEX16 + #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 CCTK_COMPLEX32 + #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; diff --git a/src/ReductionNorm1.c b/src/ReductionNorm1.c index 92299d4..8671e6e 100644 --- a/src/ReductionNorm1.c +++ b/src/ReductionNorm1.c @@ -256,22 +256,22 @@ static int ReductionL1 (int N_dims, int operator_handle, case CCTK_VARIABLE_INT: ierr = LocalReduce_Norm1_INT(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 CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: ierr = LocalReduce_Norm1_INT1(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 CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: ierr = LocalReduce_Norm1_INT2(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 CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: ierr = LocalReduce_Norm1_INT4(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 CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: ierr = LocalReduce_Norm1_INT8(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; @@ -279,17 +279,17 @@ static int ReductionL1 (int N_dims, int operator_handle, case CCTK_VARIABLE_REAL: ierr = LocalReduce_Norm1_REAL(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 CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: ierr = LocalReduce_Norm1_REAL4(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 CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: ierr = LocalReduce_Norm1_REAL8(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 CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: ierr = 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; @@ -297,17 +297,17 @@ static int ReductionL1 (int N_dims, int operator_handle, case CCTK_VARIABLE_COMPLEX: ierr = 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 CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: ierr = 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 CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: ierr = 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 CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: ierr = 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; @@ -345,22 +345,22 @@ static int ReductionL1 (int N_dims, int operator_handle, case CCTK_VARIABLE_INT: *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / weight_sum; break; - #ifdef CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / weight_sum; break; #endif - #ifdef CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / weight_sum; break; #endif - #ifdef CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / weight_sum; break; #endif - #ifdef CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / weight_sum; break; @@ -368,17 +368,17 @@ static int ReductionL1 (int N_dims, int operator_handle, case CCTK_VARIABLE_REAL: *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / weight_sum; break; - #ifdef CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / weight_sum; break; #endif - #ifdef CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / weight_sum; break; #endif - #ifdef CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / weight_sum; break; @@ -387,19 +387,19 @@ static int ReductionL1 (int N_dims, int operator_handle, (*( (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 CCTK_COMPLEX8 + #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 CCTK_COMPLEX16 + #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 CCTK_COMPLEX32 + #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; @@ -427,22 +427,22 @@ static int ReductionL1 (int N_dims, int operator_handle, case CCTK_VARIABLE_INT: *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / num_points; break; - #ifdef CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / num_points; break; #endif - #ifdef CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / num_points; break; #endif - #ifdef CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / num_points; break; #endif - #ifdef CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / num_points; break; @@ -450,17 +450,17 @@ static int ReductionL1 (int N_dims, int operator_handle, case CCTK_VARIABLE_REAL: *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / num_points; break; - #ifdef CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / num_points; break; #endif - #ifdef CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / num_points; break; #endif - #ifdef CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; break; @@ -469,19 +469,19 @@ static int ReductionL1 (int N_dims, int operator_handle, (*( (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 CCTK_COMPLEX8 + #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 CCTK_COMPLEX16 + #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 CCTK_COMPLEX32 + #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; diff --git a/src/ReductionNorm2.c b/src/ReductionNorm2.c index 36a0123..c3b791a 100644 --- a/src/ReductionNorm2.c +++ b/src/ReductionNorm2.c @@ -160,13 +160,13 @@ static int ReductionL2 (int N_dims, int operator_handle, /* temporary complex variables*/ CCTK_COMPLEX cmplx_tmp; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 CCTK_COMPLEX8 cmplx_tmp8; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 CCTK_COMPLEX16 cmplx_tmp16; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 CCTK_COMPLEX32 cmplx_tmp32; #endif @@ -270,22 +270,22 @@ static int ReductionL2 (int N_dims, int operator_handle, case CCTK_VARIABLE_INT: num_points = LocalReduce_Norm2_INT(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 CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: num_points = LocalReduce_Norm2_INT1(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 CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: num_points = LocalReduce_Norm2_INT2(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 CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: num_points = LocalReduce_Norm2_INT4(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 CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: num_points = LocalReduce_Norm2_INT8(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; @@ -293,17 +293,17 @@ static int ReductionL2 (int N_dims, int operator_handle, case CCTK_VARIABLE_REAL: num_points = LocalReduce_Norm2_REAL(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 CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: num_points = LocalReduce_Norm2_REAL4(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 CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: num_points = LocalReduce_Norm2_REAL8(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 CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: 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; @@ -311,17 +311,17 @@ static int ReductionL2 (int N_dims, int operator_handle, 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 CCTK_COMPLEX8 + #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 CCTK_COMPLEX16 + #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 CCTK_COMPLEX32 + #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; @@ -362,25 +362,25 @@ static int ReductionL2 (int N_dims, int operator_handle, *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / weight_sum; *( (CCTK_INT *) output_numbers[i]) = sqrt( *( (CCTK_INT *) output_numbers[i])); break; - #ifdef CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / weight_sum; *( (CCTK_INT1 *) output_numbers[i]) = sqrt(*( (CCTK_INT1 *) output_numbers[i])); break; #endif - #ifdef CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / weight_sum; *( (CCTK_INT2 *) output_numbers[i]) = sqrt(*( (CCTK_INT2 *) output_numbers[i])); break; #endif - #ifdef CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / weight_sum; *( (CCTK_INT4 *) output_numbers[i]) = sqrt( *( (CCTK_INT4 *) output_numbers[i])); break; #endif - #ifdef CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / weight_sum; *( (CCTK_INT8 *) output_numbers[i]) = sqrt(*( (CCTK_INT8 *) output_numbers[i])); @@ -390,19 +390,19 @@ static int ReductionL2 (int N_dims, int operator_handle, *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / weight_sum; *( (CCTK_REAL *) output_numbers[i]) = sqrt(*( (CCTK_REAL *) output_numbers[i])); break; - #ifdef CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / weight_sum; *( (CCTK_REAL4 *) output_numbers[i]) = sqrt(*( (CCTK_REAL4 *) output_numbers[i])); break; #endif - #ifdef CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / weight_sum; *( (CCTK_REAL8 *) output_numbers[i]) = sqrt(*( (CCTK_REAL8 *) output_numbers[i])); break; #endif - #ifdef CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / weight_sum; *( (CCTK_REAL16 *) output_numbers[i]) = sqrt(*( (CCTK_REAL16 *) output_numbers[i])); @@ -417,7 +417,7 @@ static int ReductionL2 (int N_dims, int operator_handle, (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re; (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im; break; - #ifdef CCTK_COMPLEX8 + #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; @@ -428,7 +428,7 @@ static int ReductionL2 (int N_dims, int operator_handle, (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im; break; #endif - #ifdef CCTK_COMPLEX16 + #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; @@ -439,7 +439,7 @@ static int ReductionL2 (int N_dims, int operator_handle, (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im; break; #endif - #ifdef CCTK_COMPLEX32 + #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; @@ -474,25 +474,25 @@ static int ReductionL2 (int N_dims, int operator_handle, *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / num_points; *( (CCTK_INT *) output_numbers[i]) = sqrt( *( (CCTK_INT *) output_numbers[i])); break; - #ifdef CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / num_points; *( (CCTK_INT1 *) output_numbers[i]) = sqrt(*( (CCTK_INT1 *) output_numbers[i])); break; #endif - #ifdef CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / num_points; *( (CCTK_INT2 *) output_numbers[i]) = sqrt(*( (CCTK_INT2 *) output_numbers[i])); break; #endif - #ifdef CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / num_points; *( (CCTK_INT4 *) output_numbers[i]) = sqrt( *( (CCTK_INT4 *) output_numbers[i])); break; #endif - #ifdef CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / num_points; *( (CCTK_INT8 *) output_numbers[i]) = sqrt(*( (CCTK_INT8 *) output_numbers[i])); @@ -502,19 +502,19 @@ static int ReductionL2 (int N_dims, int operator_handle, *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / num_points; *( (CCTK_REAL *) output_numbers[i]) = sqrt(*( (CCTK_REAL *) output_numbers[i])); break; - #ifdef CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / num_points; *( (CCTK_REAL4 *) output_numbers[i]) = sqrt(*( (CCTK_REAL4 *) output_numbers[i])); break; #endif - #ifdef CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / num_points; *( (CCTK_REAL8 *) output_numbers[i]) = sqrt(*( (CCTK_REAL8 *) output_numbers[i])); break; #endif - #ifdef CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; *( (CCTK_REAL16 *) output_numbers[i]) = sqrt(*( (CCTK_REAL16 *) output_numbers[i])); @@ -529,7 +529,7 @@ static int ReductionL2 (int N_dims, int operator_handle, (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re; (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im; break; - #ifdef CCTK_COMPLEX8 + #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; @@ -540,7 +540,7 @@ static int ReductionL2 (int N_dims, int operator_handle, (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im; break; #endif - #ifdef CCTK_COMPLEX16 + #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; @@ -551,7 +551,7 @@ static int ReductionL2 (int N_dims, int operator_handle, (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im; break; #endif - #ifdef CCTK_COMPLEX32 + #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; diff --git a/src/ReductionNorm3.c b/src/ReductionNorm3.c index 5c2ccf7..6e67519 100644 --- a/src/ReductionNorm3.c +++ b/src/ReductionNorm3.c @@ -160,13 +160,13 @@ static int ReductionL3 (int N_dims, int operator_handle, /* temporary complex variables*/ CCTK_COMPLEX cmplx_tmp; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 CCTK_COMPLEX8 cmplx_tmp8; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 CCTK_COMPLEX16 cmplx_tmp16; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 CCTK_COMPLEX32 cmplx_tmp32; #endif @@ -267,22 +267,22 @@ static int ReductionL3 (int N_dims, int operator_handle, case CCTK_VARIABLE_INT: ierr = LocalReduce_Norm3_INT(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 CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: ierr = LocalReduce_Norm3_INT1(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 CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: ierr = LocalReduce_Norm3_INT2(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 CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: ierr = LocalReduce_Norm3_INT4(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 CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: ierr = LocalReduce_Norm3_INT8(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; @@ -290,17 +290,17 @@ static int ReductionL3 (int N_dims, int operator_handle, case CCTK_VARIABLE_REAL: ierr = LocalReduce_Norm3_REAL(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 CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: ierr = LocalReduce_Norm3_REAL4(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 CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: ierr = LocalReduce_Norm3_REAL8(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 CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: ierr = 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; @@ -308,17 +308,17 @@ static int ReductionL3 (int N_dims, int operator_handle, case CCTK_VARIABLE_COMPLEX: ierr = 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 CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: ierr = 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 CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: ierr = 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 CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: ierr = 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; @@ -359,25 +359,25 @@ static int ReductionL3 (int N_dims, int operator_handle, *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / num_points; *( (CCTK_INT *) output_numbers[i]) = pow(*( (CCTK_INT *) output_numbers[i]), 1.0/3.0); break; - #ifdef CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / num_points; *( (CCTK_INT1 *) output_numbers[i]) = pow(*( (CCTK_INT1 *) output_numbers[i]), 1.0/3.0); break; #endif - #ifdef CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / num_points; *( (CCTK_INT2 *) output_numbers[i]) = pow(*( (CCTK_INT2 *) output_numbers[i]), 1.0/3.0); break; #endif - #ifdef CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / num_points; *( (CCTK_INT4 *) output_numbers[i]) = pow( *( (CCTK_INT4 *) output_numbers[i]), 1.0/3.0); break; #endif - #ifdef CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / num_points; *( (CCTK_INT8 *) output_numbers[i]) = pow(*( (CCTK_INT8 *) output_numbers[i]), 1.0/3.0); @@ -387,19 +387,19 @@ static int ReductionL3 (int N_dims, int operator_handle, *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / num_points; *( (CCTK_REAL *) output_numbers[i]) = pow(*( (CCTK_REAL *) output_numbers[i]), 1.0/3.0); break; - #ifdef CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / num_points; *( (CCTK_REAL4 *) output_numbers[i]) = pow(*( (CCTK_REAL4 *) output_numbers[i]), 1.0/3.0); break; #endif - #ifdef CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / num_points; *( (CCTK_REAL8 *) output_numbers[i]) = pow(*( (CCTK_REAL8 *) output_numbers[i]), 1.0/3.0); break; #endif - #ifdef CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; *( (CCTK_REAL16 *) output_numbers[i]) = pow(*( (CCTK_REAL16 *) output_numbers[i]), 1.0/3.0); @@ -414,7 +414,7 @@ static int ReductionL3 (int N_dims, int operator_handle, (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re; (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im; break; - #ifdef CCTK_COMPLEX8 + #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; @@ -425,7 +425,7 @@ static int ReductionL3 (int N_dims, int operator_handle, (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im; break; #endif - #ifdef CCTK_COMPLEX16 + #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; @@ -436,7 +436,7 @@ static int ReductionL3 (int N_dims, int operator_handle, (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im; break; #endif - #ifdef CCTK_COMPLEX32 + #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; @@ -471,25 +471,25 @@ static int ReductionL3 (int N_dims, int operator_handle, *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / num_points; *( (CCTK_INT *) output_numbers[i]) = pow(*( (CCTK_INT *) output_numbers[i]), 1.0/3.0); break; - #ifdef CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / num_points; *( (CCTK_INT1 *) output_numbers[i]) = pow(*( (CCTK_INT1 *) output_numbers[i]), 1.0/3.0); break; #endif - #ifdef CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / num_points; *( (CCTK_INT2 *) output_numbers[i]) = pow(*( (CCTK_INT2 *) output_numbers[i]), 1.0/3.0); break; #endif - #ifdef CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / num_points; *( (CCTK_INT4 *) output_numbers[i]) = pow( *( (CCTK_INT4 *) output_numbers[i]), 1.0/3.0); break; #endif - #ifdef CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / num_points; *( (CCTK_INT8 *) output_numbers[i]) = pow(*( (CCTK_INT8 *) output_numbers[i]), 1.0/3.0); @@ -499,19 +499,19 @@ static int ReductionL3 (int N_dims, int operator_handle, *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / num_points; *( (CCTK_REAL *) output_numbers[i]) = pow(*( (CCTK_REAL *) output_numbers[i]), 1.0/3.0); break; - #ifdef CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / num_points; *( (CCTK_REAL4 *) output_numbers[i]) = pow(*( (CCTK_REAL4 *) output_numbers[i]), 1.0/3.0); break; #endif - #ifdef CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / num_points; *( (CCTK_REAL8 *) output_numbers[i]) = pow(*( (CCTK_REAL8 *) output_numbers[i]), 1.0/3.0); break; #endif - #ifdef CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; *( (CCTK_REAL16 *) output_numbers[i]) = pow(*( (CCTK_REAL16 *) output_numbers[i]), 1.0/3.0); @@ -526,7 +526,7 @@ static int ReductionL3 (int N_dims, int operator_handle, (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re; (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im; break; - #ifdef CCTK_COMPLEX8 + #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; @@ -537,7 +537,7 @@ static int ReductionL3 (int N_dims, int operator_handle, (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im; break; #endif - #ifdef CCTK_COMPLEX16 + #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; @@ -548,7 +548,7 @@ static int ReductionL3 (int N_dims, int operator_handle, (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im; break; #endif - #ifdef CCTK_COMPLEX32 + #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; diff --git a/src/ReductionNorm4.c b/src/ReductionNorm4.c index c945555..1685c7c 100644 --- a/src/ReductionNorm4.c +++ b/src/ReductionNorm4.c @@ -160,13 +160,13 @@ static int ReductionL4 (int N_dims, int operator_handle, /* temporary complex variables*/ CCTK_COMPLEX cmplx_tmp; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 CCTK_COMPLEX8 cmplx_tmp8; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 CCTK_COMPLEX16 cmplx_tmp16; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 CCTK_COMPLEX32 cmplx_tmp32; #endif @@ -267,22 +267,22 @@ static int ReductionL4 (int N_dims, int operator_handle, case CCTK_VARIABLE_INT: ierr = LocalReduce_Norm4_INT(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 CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: ierr = LocalReduce_Norm4_INT1(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 CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: ierr = LocalReduce_Norm4_INT2(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 CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: ierr = LocalReduce_Norm4_INT4(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 CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: ierr = LocalReduce_Norm4_INT8(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; @@ -290,17 +290,17 @@ static int ReductionL4 (int N_dims, int operator_handle, case CCTK_VARIABLE_REAL: ierr = LocalReduce_Norm4_REAL(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 CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: ierr = LocalReduce_Norm4_REAL4(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 CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: ierr = LocalReduce_Norm4_REAL8(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 CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: ierr = 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; @@ -308,17 +308,17 @@ static int ReductionL4 (int N_dims, int operator_handle, case CCTK_VARIABLE_COMPLEX: ierr = 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 CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: ierr = 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 CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: ierr = 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 CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: ierr = 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; @@ -359,25 +359,25 @@ static int ReductionL4 (int N_dims, int operator_handle, *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / weight_sum; *( (CCTK_INT *) output_numbers[i]) = pow(*( (CCTK_INT *) output_numbers[i]), 1.0/4.0); break; - #ifdef CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / weight_sum; *( (CCTK_INT1 *) output_numbers[i]) = pow(*( (CCTK_INT1 *) output_numbers[i]), 1.0/4.0); break; #endif - #ifdef CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / weight_sum; *( (CCTK_INT2 *) output_numbers[i]) = pow(*( (CCTK_INT2 *) output_numbers[i]), 1.0/4.0); break; #endif - #ifdef CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / weight_sum; *( (CCTK_INT4 *) output_numbers[i]) = pow( *( (CCTK_INT4 *) output_numbers[i]), 1.0/4.0); break; #endif - #ifdef CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / weight_sum; *( (CCTK_INT8 *) output_numbers[i]) = pow(*( (CCTK_INT8 *) output_numbers[i]), 1.0/4.0); @@ -387,19 +387,19 @@ static int ReductionL4 (int N_dims, int operator_handle, *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / weight_sum; *( (CCTK_REAL *) output_numbers[i]) = pow(*( (CCTK_REAL *) output_numbers[i]), 1.0/4.0); break; - #ifdef CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / weight_sum; *( (CCTK_REAL4 *) output_numbers[i]) = pow(*( (CCTK_REAL4 *) output_numbers[i]), 1.0/4.0); break; #endif - #ifdef CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / weight_sum; *( (CCTK_REAL8 *) output_numbers[i]) = pow(*( (CCTK_REAL8 *) output_numbers[i]), 1.0/4.0); break; #endif - #ifdef CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / weight_sum; *( (CCTK_REAL16 *) output_numbers[i]) = pow(*( (CCTK_REAL16 *) output_numbers[i]), 1.0/4.0); @@ -414,7 +414,7 @@ static int ReductionL4 (int N_dims, int operator_handle, (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re; (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im; break; - #ifdef CCTK_COMPLEX8 + #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; @@ -425,7 +425,7 @@ static int ReductionL4 (int N_dims, int operator_handle, (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im; break; #endif - #ifdef CCTK_COMPLEX16 + #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; @@ -436,7 +436,7 @@ static int ReductionL4 (int N_dims, int operator_handle, (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im; break; #endif - #ifdef CCTK_COMPLEX32 + #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; @@ -471,25 +471,25 @@ static int ReductionL4 (int N_dims, int operator_handle, *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / num_points; *( (CCTK_INT *) output_numbers[i]) = pow(*( (CCTK_INT *) output_numbers[i]), 1.0/4.0); break; - #ifdef CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / num_points; *( (CCTK_INT1 *) output_numbers[i]) = pow(*( (CCTK_INT1 *) output_numbers[i]), 1.0/4.0); break; #endif - #ifdef CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / num_points; *( (CCTK_INT2 *) output_numbers[i]) = pow(*( (CCTK_INT2 *) output_numbers[i]), 1.0/4.0); break; #endif - #ifdef CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / num_points; *( (CCTK_INT4 *) output_numbers[i]) = pow( *( (CCTK_INT4 *) output_numbers[i]), 1.0/4.0); break; #endif - #ifdef CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / num_points; *( (CCTK_INT8 *) output_numbers[i]) = pow(*( (CCTK_INT8 *) output_numbers[i]), 1.0/4.0); @@ -499,19 +499,19 @@ static int ReductionL4 (int N_dims, int operator_handle, *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / num_points; *( (CCTK_REAL *) output_numbers[i]) = pow(*( (CCTK_REAL *) output_numbers[i]), 1.0/4.0); break; - #ifdef CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / num_points; *( (CCTK_REAL4 *) output_numbers[i]) = pow(*( (CCTK_REAL4 *) output_numbers[i]), 1.0/4.0); break; #endif - #ifdef CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / num_points; *( (CCTK_REAL8 *) output_numbers[i]) = pow(*( (CCTK_REAL8 *) output_numbers[i]), 1.0/4.0); break; #endif - #ifdef CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; *( (CCTK_REAL16 *) output_numbers[i]) = pow(*( (CCTK_REAL16 *) output_numbers[i]), 1.0/4.0); @@ -526,7 +526,7 @@ static int ReductionL4 (int N_dims, int operator_handle, (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re; (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im; break; - #ifdef CCTK_COMPLEX8 + #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; @@ -537,7 +537,7 @@ static int ReductionL4 (int N_dims, int operator_handle, (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im; break; #endif - #ifdef CCTK_COMPLEX16 + #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; @@ -548,7 +548,7 @@ static int ReductionL4 (int N_dims, int operator_handle, (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im; break; #endif - #ifdef CCTK_COMPLEX32 + #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; diff --git a/src/ReductionNormInf.c b/src/ReductionNormInf.c index 9341b5a..0e6d3c7 100644 --- a/src/ReductionNormInf.c +++ b/src/ReductionNormInf.c @@ -261,22 +261,22 @@ static int ReductionLInf (int N_dims, int operator_handle, case CCTK_VARIABLE_INT: ierr = LocalReduce_NormInf_INT(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 CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: ierr = LocalReduce_NormInf_INT1(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 CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: ierr = LocalReduce_NormInf_INT2(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 CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: ierr = LocalReduce_NormInf_INT4(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 CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: ierr = LocalReduce_NormInf_INT8(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; @@ -284,17 +284,17 @@ static int ReductionLInf (int N_dims, int operator_handle, case CCTK_VARIABLE_REAL: ierr = LocalReduce_NormInf_REAL(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 CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: ierr = LocalReduce_NormInf_REAL4(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 CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: ierr = LocalReduce_NormInf_REAL8(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 CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: ierr = 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; @@ -302,17 +302,17 @@ static int ReductionLInf (int N_dims, int operator_handle, case CCTK_VARIABLE_COMPLEX: ierr = 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 CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: ierr = 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 CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: ierr = 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 CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: ierr = 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; @@ -350,22 +350,22 @@ static int ReductionLInf (int N_dims, int operator_handle, case CCTK_VARIABLE_INT: *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / weight_sum; break; - #ifdef CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / weight_sum; break; #endif - #ifdef CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / weight_sum; break; #endif - #ifdef CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / weight_sum; break; #endif - #ifdef CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / weight_sum; break; @@ -373,17 +373,17 @@ static int ReductionLInf (int N_dims, int operator_handle, case CCTK_VARIABLE_REAL: *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / weight_sum; break; - #ifdef CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / weight_sum; break; #endif - #ifdef CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / weight_sum; break; #endif - #ifdef CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / weight_sum; break; @@ -392,19 +392,19 @@ static int ReductionLInf (int N_dims, int operator_handle, (*( (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 CCTK_COMPLEX8 + #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 CCTK_COMPLEX16 + #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 CCTK_COMPLEX32 + #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; @@ -432,22 +432,22 @@ static int ReductionLInf (int N_dims, int operator_handle, case CCTK_VARIABLE_INT: *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / num_points; break; - #ifdef CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / num_points; break; #endif - #ifdef CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / num_points; break; #endif - #ifdef CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / num_points; break; #endif - #ifdef CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / num_points; break; @@ -455,17 +455,17 @@ static int ReductionLInf (int N_dims, int operator_handle, case CCTK_VARIABLE_REAL: *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / num_points; break; - #ifdef CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / num_points; break; #endif - #ifdef CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / num_points; break; #endif - #ifdef CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; break; @@ -474,19 +474,19 @@ static int ReductionLInf (int N_dims, int operator_handle, (*( (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 CCTK_COMPLEX8 + #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 CCTK_COMPLEX16 + #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 CCTK_COMPLEX32 + #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; diff --git a/src/ReductionSum.c b/src/ReductionSum.c index d132611..bac8635 100644 --- a/src/ReductionSum.c +++ b/src/ReductionSum.c @@ -254,22 +254,22 @@ static int ReductionSum (int N_dims, int operator_handle, case CCTK_VARIABLE_INT: num_points = LocalReduce_Sum_INT(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 CCTK_INT1 + #ifdef HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: num_points = LocalReduce_Sum_INT1(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 CCTK_INT2 + #ifdef HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: num_points = LocalReduce_Sum_INT2(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 CCTK_INT4 + #ifdef HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: num_points = LocalReduce_Sum_INT4(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 CCTK_INT8 + #ifdef HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: num_points = LocalReduce_Sum_INT8(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; @@ -277,17 +277,17 @@ static int ReductionSum (int N_dims, int operator_handle, case CCTK_VARIABLE_REAL: num_points = LocalReduce_Sum_REAL(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 CCTK_REAL4 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: num_points = LocalReduce_Sum_REAL4(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 CCTK_REAL8 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: num_points = LocalReduce_Sum_REAL8(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 CCTK_REAL16 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: 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; @@ -295,17 +295,17 @@ static int ReductionSum (int N_dims, int operator_handle, 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 CCTK_COMPLEX8 + #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 CCTK_COMPLEX16 + #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 CCTK_COMPLEX32 + #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; diff --git a/src/SumFunctions.c b/src/SumFunctions.c index dca7920..a01a5ce 100644 --- a/src/SumFunctions.c +++ b/src/SumFunctions.c @@ -50,22 +50,22 @@ int LocalReduce_Sum_BYTE(int i, int weight_on, const void * const weight, CCTK_I case CCTK_VARIABLE_INT: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT1 case CCTK_VARIABLE_INT1: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT2 case CCTK_VARIABLE_INT2: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT4 case CCTK_VARIABLE_INT4: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 HAVE_CCTK_INT8 case CCTK_VARIABLE_INT8: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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; @@ -73,17 +73,17 @@ int LocalReduce_Sum_BYTE(int i, int weight_on, const void * const weight, CCTK_I case CCTK_VARIABLE_REAL: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL4 case CCTK_VARIABLE_REAL4: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL8 case CCTK_VARIABLE_REAL8: ITERATE_ON_ARRAY(i,CCTK_BYTE, 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 + #ifdef HAVE_CCTK_REAL16 case CCTK_VARIABLE_REAL16: 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; @@ -128,7 +128,7 @@ int LocalReduce_Sum_BYTE(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -149,8 +149,8 @@ int LocalReduce_Sum_BYTE(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd8( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar); +#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) @@ -169,7 +169,7 @@ int LocalReduce_Sum_BYTE(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -190,8 +190,8 @@ int LocalReduce_Sum_BYTE(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd16( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar); +#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) @@ -211,7 +211,7 @@ int LocalReduce_Sum_BYTE(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -232,8 +232,8 @@ int LocalReduce_Sum_BYTE(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd32( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar); +#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) @@ -288,22 +288,22 @@ int LocalReduce_Sum_INT(int i, int weight_on, const void * const weight, CCTK_IN 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -311,17 +311,17 @@ int LocalReduce_Sum_INT(int i, int weight_on, const void * const weight, CCTK_IN 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 CCTK_REAL4 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -365,7 +365,7 @@ int LocalReduce_Sum_INT(int i, int weight_on, const void * const weight, CCTK_IN #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -386,8 +386,8 @@ int LocalReduce_Sum_INT(int i, int weight_on, const void * const weight, CCTK_IN #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_CmplxAdd8( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar); +#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) @@ -406,7 +406,7 @@ int LocalReduce_Sum_INT(int i, int weight_on, const void * const weight, CCTK_IN break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -427,8 +427,8 @@ int LocalReduce_Sum_INT(int i, int weight_on, const void * const weight, CCTK_IN #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_CmplxAdd16( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar); +#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) @@ -447,7 +447,7 @@ int LocalReduce_Sum_INT(int i, int weight_on, const void * const weight, CCTK_IN break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -468,8 +468,8 @@ int LocalReduce_Sum_INT(int i, int weight_on, const void * const weight, CCTK_IN #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_CmplxAdd32( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar); +#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) @@ -491,7 +491,7 @@ int LocalReduce_Sum_INT(int i, int weight_on, const void * const weight, CCTK_IN return num_points; } -#ifdef CCTK_INT1 +#ifdef HAVE_CCTK_INT1 int LocalReduce_Sum_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; @@ -524,22 +524,22 @@ int LocalReduce_Sum_INT1(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_INT12 + #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 CCTK_INT14 + #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 CCTK_INT18 + #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; @@ -547,17 +547,17 @@ int LocalReduce_Sum_INT1(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -601,7 +601,7 @@ int LocalReduce_Sum_INT1(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -622,8 +622,8 @@ int LocalReduce_Sum_INT1(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd8( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar); +#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) @@ -642,7 +642,7 @@ int LocalReduce_Sum_INT1(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -663,8 +663,8 @@ int LocalReduce_Sum_INT1(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd16( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar); +#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) @@ -684,7 +684,7 @@ int LocalReduce_Sum_INT1(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -705,8 +705,8 @@ int LocalReduce_Sum_INT1(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd32( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar); +#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) @@ -730,7 +730,7 @@ int LocalReduce_Sum_INT1(int i, int weight_on, const void * const weight, CCTK_I } #endif -#ifdef CCTK_INT2 +#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; @@ -763,22 +763,22 @@ int LocalReduce_Sum_INT2(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_INT22 + #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 CCTK_INT24 + #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 CCTK_INT28 + #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; @@ -786,17 +786,17 @@ int LocalReduce_Sum_INT2(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -840,7 +840,7 @@ int LocalReduce_Sum_INT2(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -861,8 +861,8 @@ int LocalReduce_Sum_INT2(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd8( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar); +#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) @@ -881,7 +881,7 @@ int LocalReduce_Sum_INT2(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -902,8 +902,8 @@ int LocalReduce_Sum_INT2(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd16( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar); +#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) @@ -923,7 +923,7 @@ int LocalReduce_Sum_INT2(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -944,8 +944,8 @@ int LocalReduce_Sum_INT2(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd32( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar); +#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) @@ -969,7 +969,7 @@ int LocalReduce_Sum_INT2(int i, int weight_on, const void * const weight, CCTK_I } #endif -#ifdef CCTK_INT4 +#ifdef HAVE_CCTK_INT4 int LocalReduce_Sum_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; @@ -1002,22 +1002,22 @@ int LocalReduce_Sum_INT4(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1025,17 +1025,17 @@ int LocalReduce_Sum_INT4(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1079,7 +1079,7 @@ int LocalReduce_Sum_INT4(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1100,8 +1100,8 @@ int LocalReduce_Sum_INT4(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd8( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar); +#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) @@ -1120,7 +1120,7 @@ int LocalReduce_Sum_INT4(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1141,8 +1141,8 @@ int LocalReduce_Sum_INT4(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd16( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar); +#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) @@ -1162,7 +1162,7 @@ int LocalReduce_Sum_INT4(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1183,8 +1183,8 @@ int LocalReduce_Sum_INT4(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd32( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar); +#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) @@ -1208,7 +1208,7 @@ int LocalReduce_Sum_INT4(int i, int weight_on, const void * const weight, CCTK_I } #endif -#ifdef CCTK_INT8 +#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; @@ -1241,22 +1241,22 @@ int LocalReduce_Sum_INT8(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1264,17 +1264,17 @@ int LocalReduce_Sum_INT8(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1318,7 +1318,7 @@ int LocalReduce_Sum_INT8(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1339,8 +1339,8 @@ int LocalReduce_Sum_INT8(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd8( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar); +#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) @@ -1359,7 +1359,7 @@ int LocalReduce_Sum_INT8(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1380,8 +1380,8 @@ int LocalReduce_Sum_INT8(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd16( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar); +#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) @@ -1401,7 +1401,7 @@ int LocalReduce_Sum_INT8(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1422,8 +1422,8 @@ int LocalReduce_Sum_INT8(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd32( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar); +#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) @@ -1479,22 +1479,22 @@ int LocalReduce_Sum_REAL(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1502,17 +1502,17 @@ int LocalReduce_Sum_REAL(int i, int weight_on, const void * const weight, CCTK_I 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1556,7 +1556,7 @@ int LocalReduce_Sum_REAL(int i, int weight_on, const void * const weight, CCTK_I #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1577,8 +1577,8 @@ int LocalReduce_Sum_REAL(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd8( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar); +#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) @@ -1597,7 +1597,7 @@ int LocalReduce_Sum_REAL(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1618,8 +1618,8 @@ int LocalReduce_Sum_REAL(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd16( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar); +#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) @@ -1639,7 +1639,7 @@ int LocalReduce_Sum_REAL(int i, int weight_on, const void * const weight, CCTK_I break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1660,8 +1660,8 @@ int LocalReduce_Sum_REAL(int i, int weight_on, const void * const weight, CCTK_I #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_CmplxAdd32( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar); +#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) @@ -1684,7 +1684,7 @@ int LocalReduce_Sum_REAL(int i, int weight_on, const void * const weight, CCTK_I return num_points; } -#ifdef CCTK_REAL4 +#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; @@ -1717,22 +1717,22 @@ int LocalReduce_Sum_REAL4(int i, int weight_on, const void * const weight, CCTK_ 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1740,17 +1740,17 @@ int LocalReduce_Sum_REAL4(int i, int weight_on, const void * const weight, CCTK_ 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -1794,7 +1794,7 @@ int LocalReduce_Sum_REAL4(int i, int weight_on, const void * const weight, CCTK_ #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1815,8 +1815,8 @@ int LocalReduce_Sum_REAL4(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd8( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar); +#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) @@ -1835,7 +1835,7 @@ int LocalReduce_Sum_REAL4(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1856,8 +1856,8 @@ int LocalReduce_Sum_REAL4(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd16( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar); +#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) @@ -1877,7 +1877,7 @@ int LocalReduce_Sum_REAL4(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -1898,8 +1898,8 @@ int LocalReduce_Sum_REAL4(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd32( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar); +#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) @@ -1923,7 +1923,7 @@ int LocalReduce_Sum_REAL4(int i, int weight_on, const void * const weight, CCTK_ } #endif -#ifdef CCTK_REAL8 +#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; @@ -1956,22 +1956,22 @@ int LocalReduce_Sum_REAL8(int i, int weight_on, const void * const weight, CCTK_ 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -1979,17 +1979,17 @@ int LocalReduce_Sum_REAL8(int i, int weight_on, const void * const weight, CCTK_ 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2033,7 +2033,7 @@ int LocalReduce_Sum_REAL8(int i, int weight_on, const void * const weight, CCTK_ #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2054,8 +2054,8 @@ int LocalReduce_Sum_REAL8(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd8( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar); +#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) @@ -2074,7 +2074,7 @@ int LocalReduce_Sum_REAL8(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2095,8 +2095,8 @@ int LocalReduce_Sum_REAL8(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd16( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar); +#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) @@ -2116,7 +2116,7 @@ int LocalReduce_Sum_REAL8(int i, int weight_on, const void * const weight, CCTK_ break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2137,8 +2137,8 @@ int LocalReduce_Sum_REAL8(int i, int weight_on, const void * const weight, CCTK_ #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_CmplxAdd32( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar); +#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) @@ -2163,7 +2163,7 @@ int LocalReduce_Sum_REAL8(int i, int weight_on, const void * const weight, CCTK_ } #endif -#ifdef CCTK_REAL16 +#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; @@ -2196,22 +2196,22 @@ int LocalReduce_Sum_REAL16(int i, int weight_on, const void * const weight, CCTK 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 CCTK_INT1 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2219,17 +2219,17 @@ int LocalReduce_Sum_REAL16(int i, int weight_on, const void * const weight, CCTK 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 CCTK_REAL4 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2273,7 +2273,7 @@ int LocalReduce_Sum_REAL16(int i, int weight_on, const void * const weight, CCTK #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2294,8 +2294,8 @@ int LocalReduce_Sum_REAL16(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd8( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar); +#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) @@ -2314,7 +2314,7 @@ int LocalReduce_Sum_REAL16(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2335,8 +2335,8 @@ int LocalReduce_Sum_REAL16(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd16( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar); +#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) @@ -2356,7 +2356,7 @@ int LocalReduce_Sum_REAL16(int i, int weight_on, const void * const weight, CCTK break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2377,8 +2377,8 @@ int LocalReduce_Sum_REAL16(int i, int weight_on, const void * const weight, CCTK #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_CmplxAdd32( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar); +#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) @@ -2445,22 +2445,22 @@ int LocalReduce_Sum_COMPLEX(int i, int weight_on, const void * const weight, CCT 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2468,17 +2468,17 @@ int LocalReduce_Sum_COMPLEX(int i, int weight_on, const void * const weight, CCT 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2523,7 +2523,7 @@ int LocalReduce_Sum_COMPLEX(int i, int weight_on, const void * const weight, CCT #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2534,8 +2534,8 @@ int LocalReduce_Sum_COMPLEX(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd8( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar); +#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) @@ -2565,7 +2565,7 @@ int LocalReduce_Sum_COMPLEX(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2576,8 +2576,8 @@ int LocalReduce_Sum_COMPLEX(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd16( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar); +#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) @@ -2608,7 +2608,7 @@ int LocalReduce_Sum_COMPLEX(int i, int weight_on, const void * const weight, CCT break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2619,8 +2619,8 @@ int LocalReduce_Sum_COMPLEX(int i, int weight_on, const void * const weight, CCT #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_CmplxAdd32( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar); +#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) @@ -2655,7 +2655,7 @@ int LocalReduce_Sum_COMPLEX(int i, int weight_on, const void * const weight, CCT } -#ifdef CCTK_COMPLEX8 +#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; @@ -2699,22 +2699,22 @@ int LocalReduce_Sum_COMPLEX8(int i, int weight_on, const void * const weight, CC 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2722,17 +2722,17 @@ int LocalReduce_Sum_COMPLEX8(int i, int weight_on, const void * const weight, CC 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -2777,7 +2777,7 @@ int LocalReduce_Sum_COMPLEX8(int i, int weight_on, const void * const weight, CC #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2788,8 +2788,8 @@ int LocalReduce_Sum_COMPLEX8(int i, int weight_on, const void * const weight, CC #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_CmplxAdd8( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar); +#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) @@ -2819,7 +2819,7 @@ int LocalReduce_Sum_COMPLEX8(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2830,8 +2830,8 @@ int LocalReduce_Sum_COMPLEX8(int i, int weight_on, const void * const weight, CC #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_CmplxAdd16( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar); +#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) @@ -2862,7 +2862,7 @@ int LocalReduce_Sum_COMPLEX8(int i, int weight_on, const void * const weight, CC break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -2873,8 +2873,8 @@ int LocalReduce_Sum_COMPLEX8(int i, int weight_on, const void * const weight, CC #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_CmplxAdd32( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar); +#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) @@ -2909,7 +2909,7 @@ int LocalReduce_Sum_COMPLEX8(int i, int weight_on, const void * const weight, CC } #endif -#ifdef CCTK_COMPLEX16 +#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; @@ -2953,22 +2953,22 @@ int LocalReduce_Sum_COMPLEX16(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -2976,17 +2976,17 @@ int LocalReduce_Sum_COMPLEX16(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3031,7 +3031,7 @@ int LocalReduce_Sum_COMPLEX16(int i, int weight_on, const void * const weight, C #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3042,8 +3042,8 @@ int LocalReduce_Sum_COMPLEX16(int i, int weight_on, const void * const weight, C #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_CmplxAdd8( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar); +#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) @@ -3073,7 +3073,7 @@ int LocalReduce_Sum_COMPLEX16(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3084,8 +3084,8 @@ int LocalReduce_Sum_COMPLEX16(int i, int weight_on, const void * const weight, C #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_CmplxAdd16( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar); +#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) @@ -3116,7 +3116,7 @@ int LocalReduce_Sum_COMPLEX16(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3127,8 +3127,8 @@ int LocalReduce_Sum_COMPLEX16(int i, int weight_on, const void * const weight, C #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_CmplxAdd32( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar); +#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) @@ -3163,7 +3163,7 @@ int LocalReduce_Sum_COMPLEX16(int i, int weight_on, const void * const weight, C } #endif -#ifdef CCTK_COMPLEX32 +#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; @@ -3202,27 +3202,27 @@ int LocalReduce_Sum_COMPLEX32(int i, int weight_on, const void * const weight, C { /* out values type switches*/ case CCTK_VARIABLE_BYTE: - 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) + 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 + #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 CCTK_INT2 + #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 CCTK_INT4 + #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 CCTK_INT8 + #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; @@ -3230,17 +3230,17 @@ int LocalReduce_Sum_COMPLEX32(int i, int weight_on, const void * const weight, C 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 + #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 CCTK_REAL8 + #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 CCTK_REAL16 + #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; @@ -3285,7 +3285,7 @@ int LocalReduce_Sum_COMPLEX32(int i, int weight_on, const void * const weight, C #define EXTRA_STEP(a, b) break; - #ifdef CCTK_COMPLEX8 + #ifdef HAVE_CCTK_COMPLEX8 case CCTK_VARIABLE_COMPLEX8: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3296,8 +3296,8 @@ int LocalReduce_Sum_COMPLEX32(int i, int weight_on, const void * const weight, C #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_CmplxAdd8( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar); +#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) @@ -3327,7 +3327,7 @@ int LocalReduce_Sum_COMPLEX32(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX16 + #ifdef HAVE_CCTK_COMPLEX16 case CCTK_VARIABLE_COMPLEX16: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3338,8 +3338,8 @@ int LocalReduce_Sum_COMPLEX32(int i, int weight_on, const void * const weight, C #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_CmplxAdd16( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar); +#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) @@ -3370,7 +3370,7 @@ int LocalReduce_Sum_COMPLEX32(int i, int weight_on, const void * const weight, C break; #endif - #ifdef CCTK_COMPLEX32 + #ifdef HAVE_CCTK_COMPLEX32 case CCTK_VARIABLE_COMPLEX32: #undef REDUCTION_OPERATION #undef WEIGHTED_REDUCTION_OPERATION @@ -3381,8 +3381,8 @@ int LocalReduce_Sum_COMPLEX32(int i, int weight_on, const void * const weight, C #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_CmplxAdd32( Sum, scalar); -#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar); +#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) diff --git a/src/Sum_Functions.h b/src/Sum_Functions.h index 7dde9de..a5253f3 100644 --- a/src/Sum_Functions.h +++ b/src/Sum_Functions.h @@ -22,47 +22,47 @@ int LocalReduce_Sum_BYTE(int i, int weight_on, const void * const weight, CCTK_I int LocalReduce_Sum_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 CCTK_INT1 +#ifdef HAVE_CCTK_INT1 int LocalReduce_Sum_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); #endif -#ifdef CCTK_INT2 +#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); #endif -#ifdef CCTK_INT4 +#ifdef HAVE_CCTK_INT4 int LocalReduce_Sum_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); #endif -#ifdef CCTK_INT8 +#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); #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 CCTK_REAL4 +#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); #endif -#ifdef CCTK_REAL8 +#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); #endif -#ifdef CCTK_REAL16 +#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); #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); -#ifdef CCTK_COMPLEX8 +#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); #endif -#ifdef CCTK_COMPLEX16 +#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); #endif -#ifdef CCTK_COMPLEX32 +#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); #endif -- cgit v1.2.3