Simplifiction. Comments.

Author: Ash Pook

source/abacus/gen/main/Fixed.X.t4

@@ -159,6 +159,8 @@
             <#= ftd.RawTypeName #> s = f.numerator >> (<#= ftd.BitCount #> - 1); // sign of argument
             result.numerator = -f.numerator;
             <#= ftd.RawTypeName #> sr = result.numerator >> (<#= ftd.BitCount #> - 1); // sign of result
+            // Branchless saturation - the only input that can overflow is MinValue
+            // as there is no +ve equivalent, in this case saturate to MaxValue.
             result.numerator = (result.numerator & ~(sr & s)) | ((sr & s) & <#= ftd.RawTypeName #>.MaxValue);
         }
 
@@ -214,21 +216,21 @@
         }
 
         public static void Abs (ref <#= ftd.TypeName #> f, out <#= ftd.TypeName #> result) {
-            // Based on this: https://www.chessprogramming.org/Avoiding_Branches
+            // Based on: https://www.chessprogramming.org/Avoiding_Branches
             //int abs(int a) {
             //   int s = a >> 31; // cdq, signed shift, -1 if negative, else 0
             //   a ^= s;  // ones' complement if negative
             //   a -= s;  // plus one if negative -> two's complement if negative
             //   return a;
             //}
-            <#= ftd.RawTypeName #> temp = f.numerator;
-            <#= ftd.RawTypeName #> s = temp >> (<#= ftd.BitCount #> - 1); // sign of argument
-            temp ^= s;
-            temp -= s;
-            <#= ftd.RawTypeName #> sr = temp >> (<#= ftd.BitCount #> - 1); // sign of result
+            result.numerator = f.numerator;
+            <#= ftd.RawTypeName #> s = result.numerator >> (<#= ftd.BitCount #> - 1); // sign of argument
+            result.numerator ^= s;
+            result.numerator -= s;
+            <#= ftd.RawTypeName #> sr = result.numerator >> (<#= ftd.BitCount #> - 1); // sign of result
             // Branchless saturation - the only input that can overflow is MinValue
             // as there is no +ve equivalent, in this case saturate to MaxValue.
-            result.numerator = (temp & ~(sr & s)) | ((sr & s) & <#= ftd.RawTypeName #>.MaxValue);
+            result.numerator = (result.numerator & ~(sr & s)) | ((sr & s) & <#= ftd.RawTypeName #>.MaxValue);
         }
 
         public static void Sin (ref <#= ftd.TypeName #> f, out <#= ftd.TypeName #> result) {

source/abacus/src/main/Abacus.Fixed32.cs

@@ -213,6 +213,8 @@ public static void Negate (ref Fixed32 f, out Fixed32 result) {
             Int32 s = f.numerator >> (32 - 1); // sign of argument
             result.numerator = -f.numerator;
             Int32 sr = result.numerator >> (32 - 1); // sign of result
+            // Branchless saturation - the only input that can overflow is MinValue
+            // as there is no +ve equivalent, in this case saturate to MaxValue.
             result.numerator = (result.numerator & ~(sr & s)) | ((sr & s) & Int32.MaxValue);
         }
 
@@ -268,21 +270,21 @@ public static void Sqrt (ref Fixed32 f, out Fixed32 result) {
         }
 
         public static void Abs (ref Fixed32 f, out Fixed32 result) {
-            // Based on this: https://www.chessprogramming.org/Avoiding_Branches
+            // Based on: https://www.chessprogramming.org/Avoiding_Branches
             //int abs(int a) {
             //   int s = a >> 31; // cdq, signed shift, -1 if negative, else 0
             //   a ^= s;  // ones' complement if negative
             //   a -= s;  // plus one if negative -> two's complement if negative
             //   return a;
             //}
-            Int32 temp = f.numerator;
-            Int32 s = temp >> (32 - 1); // sign of argument
-            temp ^= s;
-            temp -= s;
-            Int32 sr = temp >> (32 - 1); // sign of result
+            result.numerator = f.numerator;
+            Int32 s = result.numerator >> (32 - 1); // sign of argument
+            result.numerator ^= s;
+            result.numerator -= s;
+            Int32 sr = result.numerator >> (32 - 1); // sign of result
             // Branchless saturation - the only input that can overflow is MinValue
             // as there is no +ve equivalent, in this case saturate to MaxValue.
-            result.numerator = (temp & ~(sr & s)) | ((sr & s) & Int32.MaxValue);
+            result.numerator = (result.numerator & ~(sr & s)) | ((sr & s) & Int32.MaxValue);
         }
 
         public static void Sin (ref Fixed32 f, out Fixed32 result) {

source/abacus/src/main/Abacus.Fixed64.cs

@@ -214,6 +214,8 @@ public static void Negate (ref Fixed64 f, out Fixed64 result) {
             Int64 s = f.numerator >> (64 - 1); // sign of argument
             result.numerator = -f.numerator;
             Int64 sr = result.numerator >> (64 - 1); // sign of result
+            // Branchless saturation - the only input that can overflow is MinValue
+            // as there is no +ve equivalent, in this case saturate to MaxValue.
             result.numerator = (result.numerator & ~(sr & s)) | ((sr & s) & Int64.MaxValue);
         }
 
@@ -269,21 +271,21 @@ public static void Sqrt (ref Fixed64 f, out Fixed64 result) {
         }
 
         public static void Abs (ref Fixed64 f, out Fixed64 result) {
-            // Based on this: https://www.chessprogramming.org/Avoiding_Branches
+            // Based on: https://www.chessprogramming.org/Avoiding_Branches
             //int abs(int a) {
             //   int s = a >> 31; // cdq, signed shift, -1 if negative, else 0
             //   a ^= s;  // ones' complement if negative
             //   a -= s;  // plus one if negative -> two's complement if negative
             //   return a;
             //}
-            Int64 temp = f.numerator;
-            Int64 s = temp >> (64 - 1); // sign of argument
-            temp ^= s;
-            temp -= s;
-            Int64 sr = temp >> (64 - 1); // sign of result
+            result.numerator = f.numerator;
+            Int64 s = result.numerator >> (64 - 1); // sign of argument
+            result.numerator ^= s;
+            result.numerator -= s;
+            Int64 sr = result.numerator >> (64 - 1); // sign of result
             // Branchless saturation - the only input that can overflow is MinValue
             // as there is no +ve equivalent, in this case saturate to MaxValue.
-            result.numerator = (temp & ~(sr & s)) | ((sr & s) & Int64.MaxValue);
+            result.numerator = (result.numerator & ~(sr & s)) | ((sr & s) & Int64.MaxValue);
         }
 
         public static void Sin (ref Fixed64 f, out Fixed64 result) {