Acos throws if argument out of range. More test cases.

Author: asik

src/Fix64.cs

@@ -708,70 +708,67 @@ public static Fix64 Tan(Fix64 x) {
         /// Returns the arccos of of the specified number, calculated using Atan and Sqrt
         /// This function has at least 7 decimals of accuracy.
         /// </summary>
-        public static Fix64 Acos(Fix64 x)
-        {
-            if (x.RawValue == 0)
-                return Fix64.PiOver2;
+        public static Fix64 Acos(Fix64 x) {
+            if (x < -One || x > One) {
+                throw new ArgumentOutOfRangeException(nameof(x));
+            }
+
+            if (x.RawValue == 0) return PiOver2;
 
-            Fix64 result = Fix64.Atan(Fix64.Sqrt(One - x * x) / x);
-            if (x.RawValue < 0)
-                return result + Fix64.Pi;
-            else
-                return result;
+            var result = Atan(Sqrt(One - x * x) / x);
+            return x.RawValue < 0 ? result + Pi : result;
         }
 
         /// <summary>
         /// Returns the arctan of of the specified number, calculated using Euler series
         /// This function has at least 7 decimals of accuracy.
         /// </summary>
-        public static Fix64 Atan(Fix64 z)
-        {
-            if (z.RawValue == 0)
-                return Zero;
+        public static Fix64 Atan(Fix64 z) {
+            if (z.RawValue == 0) return Zero;
 
             // Force positive values for argument
             // Atan(-z) = -Atan(z).
-            bool neg = (z.RawValue < 0);
-            if (neg) z = -z;
+            var neg = z.RawValue < 0;
+            if (neg) {
+                z = -z;
+            }
 
             Fix64 result;
+            var two = (Fix64)2;
+            var three = (Fix64)3;
 
-            if (z == One)
-                result = Pi/(Fix64)4;
-            else
-            {
-                bool invert = z > One;
-                if (invert) z = One / z;
-
-                result = One;
-                Fix64 term = One;
-
-                Fix64 zSq = z * z;
-                Fix64 zSq2 = zSq * (Fix64)2;
-                Fix64 zSqPlusOne = zSq + One;
-                Fix64 zSq12 = zSqPlusOne * (Fix64)2;
-                Fix64 dividend = zSq2;
-                Fix64 divisor = zSqPlusOne * (Fix64)3;
-
-                for (int i = 2; i < 30; i++)
-                {
-                    term *= dividend / divisor;
-                    result += term;
-
-                    dividend += zSq2;
-                    divisor += zSq12;
-
-                    if (term.RawValue == 0)
-                        break;
-                }
+            bool invert = z > One;
+            if (invert) z = One / z;
+
+            result = One;
+            var term = One;
 
-                result = result * z / zSqPlusOne;
+            var zSq = z * z;
+            var zSq2 = zSq * two;
+            var zSqPlusOne = zSq + One;
+            var zSq12 = zSqPlusOne * two;
+            var dividend = zSq2;
+            var divisor = zSqPlusOne * three;
 
-                if (invert)
-                    result = PiOver2 - result;
+            for (var i = 2; i < 30; ++i) {
+                term *= dividend / divisor;
+                result += term;
+
+                dividend += zSq2;
+                divisor += zSq12;
+
+                if (term.RawValue == 0) break;
+            }
+
+            result = result * z / zSqPlusOne;
+
+            if (invert) {
+                result = PiOver2 - result;
             }
 
-            if (neg) result = -result;
+            if (neg) {
+                result = -result;
+            }
             return result;
         }
 

tests/Fix64Tests.cs

@@ -580,14 +580,16 @@ public void FastSin()
         }
 
         [Fact]
-        public void Acos()
-        {
+        public void Acos() {
             var maxDelta = 0.00000001m;
             var deltas = new List<decimal>();
 
+            Assert.Equal(Fix64.Zero, Fix64.Acos(Fix64.One));
+            Assert.Equal(Fix64.PiOver2, Fix64.Acos(Fix64.Zero));
+            Assert.Equal(Fix64.Pi, Fix64.Acos(-Fix64.One));
+
             // Precision
-            for (var x = -1.0; x < 1.0; x += 0.001)
-            {
+            for (var x = -1.0; x < 1.0; x += 0.001) {
                 var xf = (Fix64)x;
                 var actual = (decimal)Fix64.Acos(xf);
                 var expected = (decimal)Math.Acos((double)xf);
@@ -596,20 +598,19 @@ public void Acos()
                 Assert.True(delta <= maxDelta, string.Format("Precision: Acos({0}): expected {1} but got {2}", xf, expected, actual));
             }
 
-            for (int i = 0; i < m_testCases.Length; ++i)
-            {
+            for (int i = 0; i < m_testCases.Length; ++i) {
                 var b = Fix64.FromRaw(m_testCases[i]);
 
-                if (b < -Fix64.One)
-                    continue;
-                if (b > Fix64.One)
-                    continue;
-
-                var expected = (decimal)Math.Acos((double)b);
-                var actual = (decimal)Fix64.Acos(b);
-                var delta = Math.Abs(expected - actual);
-                deltas.Add(delta);
-                Assert.True(delta <= maxDelta, string.Format("Acos({0}) = expected {1} but got {2}", b, expected, actual));
+                if (b < -Fix64.One || b > Fix64.One) {
+                    Assert.Throws<ArgumentOutOfRangeException>(() => Fix64.Acos(b));
+                }
+                else {
+                    var expected = (decimal)Math.Acos((double)b);
+                    var actual = (decimal)Fix64.Acos(b);
+                    var delta = Math.Abs(expected - actual);
+                    deltas.Add(delta);
+                    Assert.True(delta <= maxDelta, string.Format("Acos({0}) = expected {1} but got {2}", b, expected, actual));
+                }
             }
             Console.WriteLine("Max error: {0} ({1} times precision)", deltas.Max(), deltas.Max() / Fix64.Precision);
             Console.WriteLine("Average precision: {0} ({1} times precision)", deltas.Average(), deltas.Average() / Fix64.Precision);
@@ -703,14 +704,14 @@ public void Tan()
         }
 
         [Fact]
-        public void Atan()
-        {
+        public void Atan() {
             var maxDelta = 0.00000001m;
             var deltas = new List<decimal>();
 
+            Assert.Equal(Fix64.Zero, Fix64.Atan(Fix64.Zero));
+
             // Precision
-            for (var x = -1.0; x < 1.0; x += 0.0001)
-            {
+            for (var x = -1.0; x < 1.0; x += 0.0001) {
                 var xf = (Fix64)x;
                 var actual = (decimal)Fix64.Atan(xf);
                 var expected = (decimal)Math.Atan((double)xf);
@@ -720,8 +721,7 @@ public void Atan()
             }
 
             // Scalability and edge cases
-            foreach (var x in m_testCases)
-            {
+            foreach (var x in m_testCases) {
                 var xf = (Fix64)x;
                 var actual = (decimal)Fix64.Atan(xf);
                 var expected = (decimal)Math.Atan((double)xf);
@@ -732,7 +732,6 @@ public void Atan()
             Console.WriteLine("Max error: {0} ({1} times precision)", deltas.Max(), deltas.Max() / Fix64.Precision);
             Console.WriteLine("Average precision: {0} ({1} times precision)", deltas.Average(), deltas.Average() / Fix64.Precision);
         }
-
         //[Fact]
         public void AtanBenchmark()
         {