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
author: yye00 <yye00@7daa882c-dc44-4453-834e-278d26b18e6a> 2005-10-25 20:30:16 +0000
committer: yye00 <yye00@7daa882c-dc44-4453-834e-278d26b18e6a> 2005-10-25 20:30:16 +0000
commit: 6a6f2e17f2b8bd5e205a104526824972b945ce4c (patch)
tree: 392279dc8bb4c72dbf70b80c759a57f503b099d1
parent: 44fc50bcb487ee2406cc7e05595dc3bd3d56f485 (diff)
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
author	yye00 <yye00@7daa882c-dc44-4453-834e-278d26b18e6a>	2005-10-25 20:30:16 +0000
committer	yye00 <yye00@7daa882c-dc44-4453-834e-278d26b18e6a>	2005-10-25 20:30:16 +0000
commit	6a6f2e17f2b8bd5e205a104526824972b945ce4c (patch)
tree	392279dc8bb4c72dbf70b80c759a57f503b099d1
parent	44fc50bcb487ee2406cc7e05595dc3bd3d56f485 (diff)