MathematicaCompat.h: Restore macros

These were removed in c9ec36148e7d255006d732fb16c00c6a64cfa4c9, but this causes existing thorns to fail to compile.  We keep them here for compatibility.

2 files changed, 185 insertions, 131 deletions

diff --git a/Auxiliary/Cactus/KrancNumericalTools/GenericFD/src/MathematicaCompat.h b/Auxiliary/Cactus/KrancNumericalTools/GenericFD/src/MathematicaCompat.h
index a0e5540..252116c 100644
--- a/Auxiliary/Cactus/KrancNumericalTools/GenericFD/src/MathematicaCompat.h
+++ b/Auxiliary/Cactus/KrancNumericalTools/GenericFD/src/MathematicaCompat.h
@@ -1,14 +1,45 @@
+ 
+#define Power(x, y)   (pow(x,y))
+#define Sqrt(x)       (sqrt(x))
+
+
 #ifdef KRANC_C
+#  define Abs(x)        (fabs(x))
+#  define Min(x, y)     (fmin(x,y))
+#  define Max(x, y)     (fmax(x,y))
 #  define IfThen(x,y,z) ((x) ? (y) : (z))
 #else
 #  define Abs(x)        (abs(x))
 #  define IntAbs(x)     (abs(x))
 #  define Min(x, y)     (min(x,y))
 #  define Max(x, y)     (max(x,y))
-#  define Sqrt(x)       (sqrt(x))
 #  define IfThen(x,y,z) ((x)*(y) + (1-(x))*(z))
 #endif
 
+#define Exp(x)        (exp(x))
+#define Log(x)        (log(x))
+
+#define Sin(x)        (sin(x))
+#define Cos(x)        (cos(x))
+#define Tan(x)        (tan(x))
+#define Sec(x)        (1.0/cos(x))
+#define Csc(x)        (1.0/sin(x))
+#define Cot(x)        (1.0/tan(x))
+
+#define ArcSin(x)     (asin(x))
+#define ArcCos(x)     (acos(x))
+#define ArcTan(x)     (atan(x))
+#define ArcSec(x)     (cos(1.0/(x)))
+#define ArcCsc(x)     (sin(1.0/(x)))
+#define ArcCot(x)     (tan(1.0/(x)))
+
+#define Sinh(x)       (sinh(x))
+#define Cosh(x)       (cosh(x))
+#define Tanh(x)       (tanh(x))
+#define Sech(x)       (1.0/cosh(x))
+#define Csch(x)       (1.0/sinh(x))
+#define Coth(x)       (1.0/tanh(x))
+
 #ifdef KRANC_C
 #  define Sign(x)     (copysign( (CCTK_REAL) 1.0,(CCTK_REAL) (x)))
 #  define ToReal(x)   ((CCTK_REAL)(x))
diff --git a/Tools/CodeGen/CodeGenCactus.m b/Tools/CodeGen/CodeGenCactus.m
index ef7b317..5e4e788 100644
--- a/Tools/CodeGen/CodeGenCactus.m
+++ b/Tools/CodeGen/CodeGenCactus.m
@@ -65,6 +65,7 @@ GridLoop::usage = "GridLoop[block] returns a block that is looped over for every
   "grid point.  Must have previously set up the grid loop variables (see " <>
   "InitialiseGridLoopVariables.";
 ConditionalOnParameterTextual::usage = "";
+DeclareFDVariables::usage = "";
 InitialiseFDVariables::usage = "";
 ReplacePowers::usage = "";
 BoundaryLoop::usage = "";
@@ -74,8 +75,6 @@ NameRoot::usage = "";
 PartitionVarList::usage = "";
 DataType::usage = "DataType[] returns a string for the grid function data type (e.g. CCTK_REAL)";
 SetDataType::usage = "SetDataType[type] sets a string for the grid function data type (e.g. CCTK_REAL)";
-CCLBlock;
-CalculationMacros;
 
 Begin["`Private`"];
 
@@ -99,6 +98,21 @@ DefFn[
 DefFn[
   StoreVariableInLoop[dest:(_String|_Symbol), src:(_String|_Symbol)] :=
   {"vec_store_nta(", dest, ",", src, ")", EOL[]}];
+
+(*
+DefFn[
+  StoreLowPartialVariableInLoop[dest:(_String|_Symbol), src:(_String|_Symbol), count_String] :=
+  {"vec_store_nta_partial_lo(", dest, ",", src, ",", count, ")", EOL[]}];
+
+DefFn[
+  StoreHighPartialVariableInLoop[dest:(_String|_Symbol), src:(_String|_Symbol), count_String] :=
+  {"vec_store_nta_partial_hi(", dest, ",", src, ",", count, ")", EOL[]}];
+
+DefFn[
+  StoreMiddlePartialVariableInLoop[dest:(_String|_Symbol), src:(_String|_Symbol), countLow_String, countHigh_String] :=
+  {"vec_store_nta_partial_mid(", dest, ",", src, ",", countLow, ",", countHigh, ")", EOL[]}];
+*)
+
 DefFn[
   PrepareStorePartialVariableInLoop[i:(_String|_Symbol),
                                     ilo:(_String|_Symbol),
@@ -178,6 +192,20 @@ DefFn[
     }]];
 
 DefFn[
+  DeclareFDVariables[] := 
+(*
+  CommentedBlock["Declare finite differencing variables",
+    {Map[DeclareVariables[#, "CCTK_REAL"] &, {{"dx", "dy", "dz"}, 
+                                              {"dxi", "dyi", "dzi"},
+                                              {khalf,kthird,ktwothird,kfourthird,keightthird},
+                                              {"hdxi", "hdyi", "hdzi"}}],
+     "\n"},
+    {Map[DeclareVariables[#, "ptrdiff_t"] &, {{"di", "dj", "dk"}}],
+     "\n"}];
+*)
+  CommentedBlock["Declare finite differencing variables", {}]];
+
+DefFn[
   InitialiseFDSpacingVariablesC[] :=
   {
     (* DeclareAssignVariable["ptrdiff_t", "di", "CCTK_GFINDEX3D(cctkGH,1,0,0) - CCTK_GFINDEX3D(cctkGH,0,0,0)"], *)
@@ -190,8 +218,8 @@ DefFn[
     DeclareAssignVariable[DataType[], "dx", "ToReal(CCTK_DELTA_SPACE(0))"],
     DeclareAssignVariable[DataType[], "dy", "ToReal(CCTK_DELTA_SPACE(1))"],
     DeclareAssignVariable[DataType[], "dz", "ToReal(CCTK_DELTA_SPACE(2))"],
-    DeclareAssignVariable[DataType[], "dt", "ToReal(CCTK_DELTA_TIME)"],
-    DeclareAssignVariable[DataType[], "t", "ToReal(cctk_time)"]
+    DeclareAssignVariable[DataType[], "dt", "ToReal(CCTK_DELTA_TIME)"]
+    (* DeclareAssignVariable[DataType[], "t", "ToReal(cctk_time)"]*)
     }];
 
 DefFn[
@@ -235,13 +263,13 @@ DefFn[
           DeclareAssignVariable[DataType[], "hdzi", "0.5 * dzi"]}]}]];
 
 DefFn[
-  GridName[x:(_Symbol|_String)] :=
+  GridName[x_Symbol] :=
   If[SOURCELANGUAGE == "C",
      ToString[x] <> "[index]",
      ToString[x] <> "(i,j,k)"]];
 
 DefFn[
-  ArrayName[x:(_Symbol|_String)] :=
+  ArrayName[x_Symbol] :=
   If[SOURCELANGUAGE == "C",
      ToString[x] <> "[0]",
      ToString[x] <> "(1)"]];
@@ -375,8 +403,24 @@ Options[GenericGridLoop] = ThornOptions;
 
 DefFn[
   GenericGridLoop[functionName_String, block:CodeGenBlock, opts:OptionsPattern[]] :=
-     GenericGridLoopUsingLoopControl[functionName, block, OptionValue[UseVectors]]
-     ];
+  If[OptionValue[UseLoopControl],
+     GenericGridLoopUsingLoopControl[functionName, block, OptionValue[UseVectors]],
+     GenericGridLoopTraditional[block]]];
+
+DefFn[
+  GenericGridLoopTraditional[block:CodeGenBlock] :=
+  CommentedBlock[
+    "Loop over the grid points",
+    loopOverInteger[
+      "k", "imin[2]", "imax[2]",
+      loopOverInteger[
+        "j", "imin[1]", "imax[1]",
+        loopOverInteger[
+          "i", "imin[0]", "imax[0]",
+          {If[SOURCELANGUAGE == "C",
+              DeclareAssignVariable["int", "index", "CCTK_GFINDEX3D(cctkGH,i,j,k)"],
+              ""],
+            block}]]]]];
 
 DefFn[
   GenericGridLoopUsingLoopControl[functionName_String, block:CodeGenBlock, vectorise:Boolean] :=
@@ -384,8 +428,8 @@ DefFn[
      CommentedBlock[
        "Loop over the grid points",
        {"#pragma omp parallel\n",
-        If[vectorise, "LC_LOOP3VEC", "CCTK_LOOP3"],
-        "(", functionName, ",\n",
+        If[vectorise, "LC_LOOP3VEC", "LC_LOOP3"],
+        " (", functionName, ",\n",
         "  i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],\n",
         "  cctk_lsh[0],cctk_lsh[1],cctk_lsh[2]",
         If[vectorise, {",\n", "  CCTK_REAL_VEC_SIZE"}, ""],
@@ -396,7 +440,7 @@ DefFn[
            (* DeclareAssignVariable["int", "index", "CCTK_GFINDEX3D(cctkGH,i,j,k)"], *)
            DeclareAssignVariable["ptrdiff_t", "index", "di*i + dj*j + dk*k"],
            block}], "}\n",
-        If[vectorise, "LC_ENDLOOP3VEC", "CCTK_ENDLOOP3"] <> "(", functionName, ");\n"}],
+        If[vectorise, "LC_ENDLOOP3VEC", "LC_ENDLOOP3"] <> " (", functionName, ");\n"}],
      (* else *)
      ""]];
 
@@ -509,45 +553,53 @@ DefFn[
 DefFn[
   vectoriseExpression[exprp_] :=
   Module[
-    {expr, undoVect, undoSomeVect},
+    {isNotMinusOneQ, isNotTimesMinusOneQ, fmaRules, isNotKneg, arithRules, undoRules, expr},
     expr = exprp;
-    
+
     (* Constants *)
-    expr = expr /. {
-      x_Integer -> ToReal[x],
-      x_Real    -> ToReal[x],
-      E         -> ToReal[E],
-      Pi        -> ToReal[Pi]};
-    
-    (* Operators *)
-    expr = expr //. {
-      -x_                 -> kneg[x],
-      kmul[-1,x_]         -> kneg[x],
-      kmul[x_,-1]         -> kneg[x],
-      kmul[ToReal[-1],x_] -> kneg[x],
-      kmul[x_,ToReal[-1]] -> kneg[x],
-      kneg[kneg[x_]]      -> x,
-      
-      x_ + y_           -> kadd[x,y],
-      x_ - y_           -> ksub[x,y],
-      kadd[kneg[x_],y_] -> ksub[y,x],
-      ksub[kneg[x_],y_] -> kneg[kadd[x,y]],
-      kadd[x_,kneg[y_]] -> ksub[x,y],
-      ksub[x_,kneg[y_]] -> kadd[x,y],
-      kneg[ksub[x_,y_]] -> ksub[y,x],
-      ksub[x_,x_]       -> ToReal[0],
-      
-      x_ * y_              -> kmul[x,y],
-      x_ / y_              -> kdiv[x,y],
-      kdiv[x_,kdiv[y_,z_]] -> kdiv[kmul[x,z],y],
-      kdiv[kdiv[x_,y_],z_] -> kdiv[x,kmul[y,z]],
-      kmul[kneg[x_],y_]    -> kneg[kmul[x,y]],
-      kmul[x_,kneg[y_]]    -> kneg[kmul[x,y]],
-      kdiv[kneg[x_],y_]    -> kneg[kdiv[x,y]],
-      kdiv[x_,kneg[y_]]    -> kneg[kdiv[x,y]],
-      kdiv[x_,x_]          -> ToReal[1],
-      
-      Abs[x_] -> kfabs[x],
+    (* expr = expr /. xx_Integer/; xx!=-1 :> ToReal[xx]; *)
+    expr = expr /. xx_Integer -> ToReal[xx];
+    expr = expr /. xx_Real -> ToReal[xx];
+
+    removeToRealRules =
+    {-ToReal[xx_] -> ToReal[- xx],
+     ToReal[xx_] + ToReal[yy_] -> ToReal[xx + yy],
+     ToReal[xx_] - ToReal[yy_] -> ToReal[xx - yy],
+     ToReal[xx_] * ToReal[yy_] -> ToReal[xx * yy],
+     ToReal[xx_] == ToReal[yy_] -> ToReal[xx == yy],
+     ToReal[xx_] != ToReal[yy_] -> ToReal[xx != yy],
+     pow[xx_, ToReal[power_]] -> pow[xx, power]};
+
+    expr = expr //. removeToRealRules;
+
+    (* Replace all operators and functions *)
+    (* kneg, kadd, ksub, kmul, kdiv *)
+    isNotKneg[n_] := ! MatchQ[n,kneg[_]];
+
+    arithRules =
+    { - xx_ -> kneg[xx],
+      xx_ * yy_ -> kmul[xx,yy],
+      xx_ / yy_ -> kdiv[xx,yy],
+      xx_ + yy_ -> kadd[xx,yy],
+      xx_ - yy_ -> ksub[xx,yy],
+      kmul[-1,xx_]            -> kneg[xx],
+      kmul[xx_,-1]            -> kneg[xx],
+      kmul[ToReal[-1],xx_]    -> kneg[xx],
+      kmul[xx_,ToReal[-1]]    -> kneg[xx],
+      ToReal[- xx_]           -> kneg[ToReal[xx]],
+      (* kmul[xx_,INV[yy_]]      -> kdiv[xx,yy], *)
+      (* kmul[INV[xx_],yy_]      -> kdiv[yy,xx], *)
+      kdiv[xx_,kdiv[yy_,zz_]] -> kdiv[kmul[xx,zz],yy],
+      kdiv[kdiv[xx_,yy_],zz_] -> kdiv[xx,kmul[yy,zz]],
+      kmul[kneg[xx_],yy_]     -> kneg[kmul[xx,yy]],
+      kmul[xx_,kneg[yy_]]     -> kneg[kmul[xx,yy]],
+      kdiv[kneg[xx_],yy_]     -> kneg[kdiv[xx,yy]],
+      kdiv[xx_,kneg[yy_]]     -> kneg[kdiv[xx,yy]],
+      kadd[kneg[xx_],yy_]     -> ksub[yy,xx],
+      ksub[kneg[xx_],yy_]     -> kneg[kadd[xx,yy]],
+      kadd[xx_,kneg[yy_]]     -> ksub[xx,yy],
+      ksub[xx_,kneg[yy_]]     -> kadd[xx,yy],
+      kneg[ksub[xx_,yy_]]     -> ksub[yy,xx],
       acos[xx_]     -> kacos[xx],
       acosh[xx_]    -> kacosh[xx],
       asin[xx_]     -> kasin[xx],
@@ -556,18 +608,18 @@ DefFn[
       atanh[xx_]    -> katanh[xx],
       cos[xx_]      -> kcos[xx],
       cosh[xx_]     -> kcosh[xx],
+      exp[xx_]      -> kexp[xx],
+      fabs[xx_]     -> kfabs[xx],
+      fmax[xx_,yy_] -> kfmax[xx,yy],
+      fmin[xx_,yy_] -> kfmin[xx,yy],
+      log[xx_]      -> klog[xx],
+      pow[xx_,yy_]  -> kpow[xx,yy],
       sin[xx_]      -> ksin[xx],
       sinh[xx_]     -> ksinh[xx],
+      sqrt[xx_]     -> ksqrt[xx],
       tan[xx_]      -> ktan[xx],
       tanh[xx_]     -> ktanh[xx],
-      
-      exp[x_]     -> kexp[x],
-      fabs[x_]    -> kfabs[x],
-      fmax[x_,y_] -> kfmax[x,y],
-      fmin[x_,y_] -> kfmin[x,y],
-      log[x_]     -> klog[x],
-      pow[x_,y_]  -> kpow[x,y],
-      sqrt[x_]    -> ksqrt[x],
+
       (* acos[kneg[xx_]]           -> kacos[kneg[xx]], *)
       (* acosh[kneg[xx_]]          -> kacosh[kneg[xx]], *)
       kasin[kneg[xx_]]           -> kneg[kasin[xx]],
@@ -587,46 +639,47 @@ DefFn[
       kneg[kfabs[xx_]]           -> kfnabs[xx],
       kneg[kfnabs[xx_]]          -> kfabs[xx],
       kneg[kneg[xx_]]            -> xx};
+    expr = expr //. arithRules;
 
-    (* FMA (fused multiply-add) *)
+    (* Undo some transformations *)
+    undoRules = 
+    { IfThen[_, aa_, aa_] -> aa,
+      IfThen[xx_?IntegerQ, aa_, bb_] /; xx!=0 :> aa,
+      IfThen[xx_?IntegerQ, aa_, bb_] /; xx==0 :> bb,
+      IfThen[kmul[xx_,yy_], aa_, bb_] -> IfThen[xx*yy, aa, bb],
+      IfThen[kmul[xx_,yy_] != zz_, aa_, bb_] -> IfThen[xx*yy!=zz, aa, bb],
+      IfThen[ToReal[xx_], aa_, bb_] -> IfThen[xx, aa, bb],
+      Scalar[kmul[xx_,yy_]] -> Scalar[xx*yy],
+      Scalar[kmul[xx_,yy_] != zz_] -> Scalar[xx*yy!=zz],
+      Scalar[ToReal[xx_]] -> Scalar[xx],
+      Scalar[xx_ != ToReal[yy_]] -> Scalar[xx != yy],
+      ToReal[kneg[xx_]] -> ToReal[-xx],
+      ToReal[kadd[xx_,yy_]] -> ToReal[xx+yy],
+      ToReal[ksub[xx_,yy_]] -> ToReal[xx-yy],
+      ToReal[kmul[xx_,yy_]] -> ToReal[xx*yy],
+      ToReal[xx_*kadd[yy_,zz_]] -> ToReal[xx*(yy+zz)],
+      kpow[xx_, kneg[power_]] -> kpow[xx, -power]};
+    expr = expr //. undoRules;
+    
+    (* FMA (fused multiply-add) instructions *)
     (* kmadd (x,y,z) =   xy+z
        kmsub (x,y,z) =   xy-z
        knmadd(x,y,z) = -(xy+z)
        knmsub(x,y,z) = -(xy-z) *)
-    expr = expr //. {
-      kadd[kmul[x_,y_],z_] -> kmadd[x,y,z],
-      kadd[z_,kmul[x_,y_]] -> kmadd[x,y,z],
-      ksub[kmul[x_,y_],z_] -> kmsub[x,y,z],
-      ksub[z_,kmul[x_,y_]] -> knmsub[x,y,z],
-      kneg[kmadd [x_,y_,z_]] -> knmadd[x,y,z],
-      kneg[kmsub [x_,y_,z_]] -> knmsub[x,y,z],
-      kneg[knmadd[x_,y_,z_]] -> kmadd [x,y,z],
-      kneg[knmsub[x_,y_,z_]] -> kmsub [x,y,z]
+    fmaRules =
+    { kadd[kmul[xx_,yy_],zz_] -> kmadd[xx,yy,zz],
+      kadd[zz_,kmul[xx_,yy_]] -> kmadd[xx,yy,zz],
+      ksub[kmul[xx_,yy_],zz_] -> kmsub[xx,yy,zz],
+      ksub[zz_,kmul[xx_,yy_]] -> knmsub[xx,yy,zz],
+      kneg[kmadd [xx_,yy_,zz_]] -> knmadd[xx,yy,zz],
+      kneg[kmsub [xx_,yy_,zz_]] -> knmsub[xx,yy,zz],
+      kneg[knmadd[xx_,yy_,zz_]] -> kmadd [xx,yy,zz],
+      kneg[knmsub[xx_,yy_,zz_]] -> kmsub [xx,yy,zz]
       (* we could match this and similar patterns
-         kmul[x_, kadd[y_, ToReal[+1]]] -> kmadd[x, y, x],
-         kmul[x_, kadd[y_, ToReal[-1]]] -> kmsub[x, y, x],
+         kmul[xx_, kadd[yy_, ToReal[+1]]] -> kmadd[xx, yy, xx],
+         kmul[xx_, kadd[yy_, ToReal[-1]]] -> kmsub[xx, yy, xx],
          *)};
-    
-    (* Undo some transformations *)
-    undoVect[expr_] := expr //. {
-      ToReal[x_] -> x,
-      
-      kneg[x_] -> -x,
-      
-      kadd[x_,y_] -> x+y,
-      ksub[x_,y_] -> x-y,
-      kmul[x_,y_] -> x*y,
-      kdiv[x_,y_] -> x/y};
-    
-    undoSomeVect[expr_] := (
-      expr
-      /. ToReal[a_] :> ToReal[undoVect[a]]
-      /. Scalar[a_] :> Scalar[undoVect[a]]
-      /. (IfThen[a_,x_,y_] :> 
-          IfThen[undoVect[a], undoSomeVect[x], undoSomeVect[y]])
-      /. kpow[x_,a_] :> kpow[undoSomeVect[x], undoVect[a]]);
-    
-    expr = undoSomeVect[expr];
+    expr = expr //. fmaRules;
     
     Return[expr]]];
 
@@ -648,11 +701,6 @@ DefFn[
         rhs = rhs //. Power[xx_, -1/2] -> INV[sqrt[xx]];
         rhs = rhs //. Power[xx_,  0.5] -> sqrt[xx];
         rhs = rhs //. Power[xx_, -0.5] -> INV[sqrt[xx]];
-        rhs = rhs //. SQR[x_] SQR[y_] -> SQR[x y];
-        rhs = rhs //. CUB[x_] CUB[y_] -> CUB[x y];
-        rhs = rhs //. QAD[x_] QAD[y_] -> QAD[x y];
-        rhs = rhs //. INV[x_] INV[y_] -> INV[x y];
-        rhs = rhs //. sqrt[x_] sqrt[y_] -> sqrt[x y];
         
         (*
            rhs = rhs /.  1/2 ->  khalf
@@ -676,19 +724,18 @@ DefFn[
 
         (* Avoid rational numbers *)
         rhs = rhs /. Rational[xx_,yy_] :> N[xx/yy, 30];
+        
+        rhs = rhs //. IfThen[cond1_,xx1_,yy1_] + IfThen[cond2_,xx2_,yy2_] /; cond1==cond2 :> 
+        IfThen[cond1, Simplify[    xx1 +     xx2], Simplify[    yy1 +     yy2]];
+
+        rhs = rhs //. ff1_ IfThen[cond1_,xx1_,yy1_] + IfThen[cond2_,xx2_,yy2_] /; cond1==cond2 :>
+        IfThen[cond1, Simplify[ff1 xx1 +     xx2], Simplify[ff1 yy1 +     yy2]];
 
-        (* Simple optimisations *)
-        rhs = rhs /. IfThen[_, aa_, aa_] -> aa;
-        rhs = rhs /. IfThen[xx_?IntegerQ, aa_, bb_] /; xx!=0 :> aa;
-        rhs = rhs /. IfThen[xx_?IntegerQ, aa_, bb_] /; xx==0 :> bb;
-        rhs = rhs /. IfThen[True , aa_, bb_] -> aa;
-        rhs = rhs /. IfThen[False, aa_, bb_] -> bb;
+        rhs = rhs //.      IfThen[cond1_,xx1_,yy1_] + ff2_ IfThen[cond2_,xx2_,yy2_] /; cond1==cond2 :> 
+        IfThen[cond1, Simplify[    xx1 + ff2 xx2], Simplify[    yy1 + ff2 yy2]];
 
-        (* Complex optimisations *)
-        rhs = rhs //.      IfThen[cond1_,xx1_,yy1_] +      IfThen[cond2_,xx2_,yy2_] /; cond1==cond2 :> IfThen[cond1, Simplify[    xx1 +     xx2], Simplify[    yy1 +     yy2]];
-        rhs = rhs //. ff1_ IfThen[cond1_,xx1_,yy1_] +      IfThen[cond2_,xx2_,yy2_] /; cond1==cond2 :> IfThen[cond1, Simplify[ff1 xx1 +     xx2], Simplify[ff1 yy1 +     yy2]];
-        rhs = rhs //.      IfThen[cond1_,xx1_,yy1_] + ff2_ IfThen[cond2_,xx2_,yy2_] /; cond1==cond2 :> IfThen[cond1, Simplify[    xx1 + ff2 xx2], Simplify[    yy1 + ff2 yy2]];
-        rhs = rhs //. ff1_ IfThen[cond1_,xx1_,yy1_] + ff2_ IfThen[cond2_,xx2_,yy2_] /; cond1==cond2 :> IfThen[cond1, Simplify[ff1 xx1 + ff2 xx2], Simplify[ff1 yy1 + ff2 yy2]];
+        rhs = rhs //. ff1_ IfThen[cond1_,xx1_,yy1_] + ff2_ IfThen[cond2_,xx2_,yy2_] /; cond1==cond2 :> 
+        IfThen[cond1, Simplify[ff1 xx1 + ff2 xx2], Simplify[ff1 yy1 + ff2 yy2]];
 
         (* Is this still a good idea when FMA instructions are used? *)
         If[!noSimplify,
@@ -702,8 +749,7 @@ DefFn[
            from here. *)
         rhs = rhs //. Power[E, power_] -> exp[power];
         rhs = rhs //. Log[x_] -> log[x];
-        (* rhs = rhs //. Power[x_, n_Integer] -> pown[x,n]; *)
-        rhs = rhs //. Power[x_, power_] :> pow[x,power];
+        rhs = rhs //. Power[x_, y_] -> pow[x,y];
         rhs = rhs //. Sin[x_] -> sin[x];
         rhs = rhs //. Cos[x_] -> cos[x];
         rhs = rhs //. Tan[x_] -> tan[x];
@@ -740,7 +786,6 @@ DefFn[
         rhs = rhs //. Max[xx_, yy__] -> fmax[xx, Max[yy]];
         rhs = rhs //. Min[xx_, yy__] -> fmin[xx, Min[yy]];
         rhs = rhs //. Abs[x_] -> fabs[x];
-        rhs = rhs //. IntAbs[x_] -> abs[x];
 
         If[vectorise === True,
            rhs = vectoriseExpression[rhs]];
@@ -752,28 +797,6 @@ DefFn[
     (*       Print[rhs//FullForm];*)
     rhs]];
 
-DefFn[
-  CCLBlock[type_String, name_String, attrs:{(_String -> CodeGenBlock)...},
-           contents:CodeGenBlock,comment_String:""] :=
-  {type, " ", name,
-   Map[" "<>#[[1]]<>"="<>#[[2]] &, attrs], "\n",
-   CBlock[contents],
-   If[comment === "", "", Quote[comment]],"\n"}];
-
-CalculationMacros[vectorise_:False] :=
-  CommentedBlock["Define macros used in calculations",
-      Map[{"#define ", #, "\n"} &,
-         {"INITVALUE (42)",
-          "QAD(x) (SQR(SQR(x)))"} ~Join~
-          If[vectorise,
-           {"INV(x) (kdiv(ToReal(1.0),x))",
-            "SQR(x) (kmul(x,x))",
-            "CUB(x) (kmul(x,SQR(x)))"},
-           {"INV(x) ((1.0) / (x))",
-            "SQR(x) ((x) * (x))",
-            "CUB(x) ((x) * (x) * (x))"}]
-         ]];
-
 End[];
 
 EndPackage[];