Merge pull request #854 from quajak/master

Rewrite of more math functions

Tests/Cosmos.Compiler.Tests.Bcl/System/BitConverterTest.cs

@@ -38,7 +38,6 @@ namespace Cosmos.Compiler.Tests.Bcl.System
 
             Assert.IsTrue((result == expectedResult), "BitConverter.ToString(ulongBytes) doesn't work: result " + result + " != " + expectedResult);
 
-
             // This test works, what is the difference with double? That is saved as an Int32 in oly a register?
             float aFloat = 1.0f;
 
@@ -49,9 +48,38 @@ namespace Cosmos.Compiler.Tests.Bcl.System
 
             Assert.IsTrue((result == expectedResult), "BitConverter.ToString(floatBytes) doesn't work: result " + result + " != " + expectedResult);
 
+            double Result;
+            byte[] doubleBytes = BitConverter.GetBytes(0d);
+            Result = BitConverter.ToDouble(doubleBytes, 0);
+            Assert.IsTrue(Result == 0f, "BitConverter.ToDouble works with 0");
+
+            doubleBytes = BitConverter.GetBytes(1d);
+            Result = BitConverter.ToDouble(doubleBytes, 0);
+            Assert.IsTrue(Result == 1f, "BitConverter.ToDouble works with 1");
+
+            doubleBytes = BitConverter.GetBytes(2d);
+            Result = BitConverter.ToDouble(doubleBytes, 0);
+            Assert.IsTrue(Result == 2f, "BitConverter.ToDouble works with 2");
+
+            doubleBytes = BitConverter.GetBytes(101d);
+            Result = BitConverter.ToDouble(doubleBytes, 0);
+            Assert.IsTrue(Result == 101f, "BitConverter.ToDouble works with 101");
+
+            doubleBytes = BitConverter.GetBytes(-101d);
+            Result = BitConverter.ToDouble(doubleBytes, 0);
+            Assert.IsTrue(Result == -101f, "BitConverter.ToDouble works with -101");
+
+            doubleBytes = BitConverter.GetBytes(1.2345d);
+            Result = BitConverter.ToDouble(doubleBytes, 0);
+            Assert.IsTrue(Result == 1.2345, "BitConverter.ToDouble works with 1.2345");
+
+            doubleBytes = BitConverter.GetBytes(-1.2345d);
+            Result = BitConverter.ToDouble(doubleBytes, 0);
+            Assert.IsTrue(Result == -1.2345, "BitConverter.ToDouble works with -1.2345");
+
             double aDouble = 1.0;
 
-            byte[] doubleBytes = BitConverter.GetBytes(aDouble);
+            doubleBytes = BitConverter.GetBytes(aDouble);
 
             result = BitConverter.ToString(doubleBytes, 0);
             expectedResult = "00-00-00-00-00-00-F0-3F";

Tests/Cosmos.Compiler.Tests.Bcl/System/MathTest.cs

@@ -10,6 +10,157 @@ namespace Cosmos.Compiler.Tests.Bcl.System
         {
             double result;
 
+            #region Math.Asin
+
+            result = Math.Asin(1.1);
+            Assert.IsTrue(double.IsNaN(result), "Math.Asin returns NaN for values larger than 1");
+
+            result = Math.Asin(-1.1);
+            Assert.IsTrue(double.IsNaN(result), "Math.Asin returns NaN for values smaller than -1");
+
+            result = Math.Asin(1);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 1.5707963267949), "Asin returns correct value for 1");
+
+            result = Math.Asin(-1);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, -1.5707963267949), "Asin returns correct value for -1");
+
+            result = Math.Asin(0);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 0), "Asin returns correct value for 9");
+
+            #endregion Math.Asin
+
+            #region Math.Acos
+
+            result = Math.Acos(1.1);
+            Assert.IsTrue(double.IsNaN(result), "Math.Acos returns NaN for values larger than 1");
+
+            result = Math.Acos(-1.1);
+            Assert.IsTrue(double.IsNaN(result), "Math.Acos returns NaN for values smaller than -1");
+
+            result = Math.Acos(1);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 0), "Acos returns correct value for 1");
+
+            result = Math.Acos(-1);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, Math.PI), "Acos returns correct value for -1");
+
+            result = Math.Acos(0);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 1.5707963267949), "Acos returns correct value for 9");
+
+            #endregion Math.Acos
+
+            #region Math.Cos
+
+            result = Math.Cos(4);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, -0.6536436208636), "Math.Cos works with positive number");
+
+            result = Math.Cos(0);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 1), "Cos works with 0");
+
+            result = Math.Cos(1);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 0.5403023058681), "Cos gives correct answer for 1");
+
+            result = Math.Cos(-1);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 0.5403023058681), "Cos gives correct answer for -1");
+
+            result = Math.Cos(double.NaN);
+            Assert.IsTrue(double.IsNaN(result), "Cos works with NaN");
+
+            result = Math.Cos(double.PositiveInfinity);
+            Assert.IsTrue(double.IsNaN(result), "Cos works with INF");
+
+            result = Math.Cos(double.PositiveInfinity);
+            Assert.IsTrue(double.IsNaN(result), "Cos works with -INF");
+
+            result = Math.Cos(Math.PI);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, -1), "Cos gives correct answer for PI");
+
+            result = Math.Cos(Math.PI / 2);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 6.12323399573677E-17), "Cos gives correct answer for PI / 2");
+
+            result = Math.Cos(Math.PI / 3);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 0.5), "Cos gives correct answer for PI / 3");
+
+            #endregion Math.Cos
+
+            #region Math.Log
+
+            result = Math.Log(10);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 2.30258509299405), "Math.Log base e works with positive numbers");
+
+            result = Math.Log(Math.E);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 1), "Math.Log base gives correct value for e");
+
+            result = Math.Log(Math.E * Math.E);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 2), "Math.Log base gives correct value for e^2");
+
+            result = Math.Log(0);
+            Assert.IsTrue(double.IsNegativeInfinity(result), "Math.Log base e gives correct value for 0");
+
+            result = Math.Log(-1.5);
+            Assert.IsTrue(double.IsNaN(result), "Math.Log base e gives correct answer for negative numbers");
+
+            result = Math.Log(double.NaN);
+            Assert.IsTrue(double.IsNaN(result), "Log base e returns NaN for NaN");
+
+            result = Math.Log(double.PositiveInfinity);
+            Assert.IsTrue(double.IsPositiveInfinity(result), "Log base e return INF for INF");
+
+            result = Math.Log(double.NegativeInfinity);
+            Assert.IsTrue(double.IsNaN(result), "Log base e return NaN for -INF");
+
+            result = Math.Log10(100);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 2), "Math.Log10 gives correct value for integer exponent");
+
+            result = Math.Log(50);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 3.91202300542814), "Log10 gives correct value for double exponent");
+
+            result = Math.Log10(double.NaN);
+            Assert.IsTrue(double.IsNaN(result), "Log10 returns NaN when being called with NaN");
+
+            result = Math.Log(4, 2);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 2), "Log with base gives correct result with called with int values");
+
+            result = Math.Log(7.5, 2.5);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 2.19897784671579), "Log with base gives correct result with double values");
+
+            #endregion Math.Log
+
+            #region Math.Sin
+
+            result = Math.Sin(4);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, -0.7568024953079), "Math.Sin works with positive number");
+
+            result = Math.Sin(0);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 0), "Sin works with 0");
+
+            result = Math.Sin(1);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 0.8414709848079), "Sin gives correct answer for 1");
+
+            result = Math.Sin(-1);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, -0.8414709848079), "Sin gives correct answer for -1");
+
+            result = Math.Sin(double.NaN);
+            Assert.IsTrue(double.IsNaN(result), "Sin works with NaN");
+
+            result = Math.Sin(double.PositiveInfinity);
+            Assert.IsTrue(double.IsNaN(result), "Sin works with INF");
+
+            result = Math.Sin(double.PositiveInfinity);
+            Assert.IsTrue(double.IsNaN(result), "Sin works with -INF");
+
+            result = Math.Sin(Math.PI);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 1.22464679914735E-16), "Sin gives correct answer for PI");
+
+            result = Math.Sin(Math.PI / 2);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 1), "Sin gives correct answer for PI / 2");
+
+            result = Math.Sin(Math.PI / 3);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 0.866025403784439), "Sin gives correct answer for PI / 3");
+
+            #endregion Math.Sin
+
+            #region Math.Sqrt
+
             // Test with small number
             result = Math.Sqrt(16);
             Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 4), "Sqrt does not produce accurate result with small input");
@@ -34,6 +185,8 @@ namespace Cosmos.Compiler.Tests.Bcl.System
             result = Math.Sqrt(double.PositiveInfinity);
             Assert.IsTrue(double.IsPositiveInfinity(result), "Sqrt of PositiveInfinity must return PositiveInfinity");
 
+            #endregion Math.Sqrt
+
             #region Math.Exp
 
             //Test with integer
@@ -153,6 +306,80 @@ namespace Cosmos.Compiler.Tests.Bcl.System
             Assert.IsTrue(double.IsPositiveInfinity(result), "Pow gives correct solution when x is INF and y > 0 ");
 
             #endregion Math.Pow
+
+            #region Math.Tan
+
+            result = Math.Tan(0);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 0), "Tan works with 0");
+
+            result = Math.Tan(1);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 1.5574077246549), "Tan works with 1");
+
+            result = Math.Tan(-1);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, -1.5574077246549), "Tan works with -1");
+
+            result = Math.Tan(10);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 0.648360827459087), "Tan works with big numbers such as 10");
+
+            result = Math.Tan(-10);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, -0.648360827459087), "Tan works with larger negative numbers");
+
+            result = Math.Tan(0.5);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 0.54630248984379), "Tan works with doubles");
+
+            result = Math.Tan(-0.5);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, -0.54630248984379), "Tan works with negative doubles");
+
+            result = Math.Tan(Math.PI);
+            Assert.IsTrue(result <= -.22464679914735E-16, "Tan gives matching result for Pi but mathematically inaccurate result. " + result);
+
+            result = Math.Tan(Math.PI / 2);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 1.63312393531954E+16), "Tan gives result matching normal Math function but incorrect in mathematical sense");
+
+            result = Math.Tan(Math.PI / 3);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, Math.Sqrt(3)), "Tan gives correct value for PI / 3");
+
+            result = Math.Tan(double.NegativeInfinity);
+            Assert.IsTrue(double.IsNaN(result), "Tan return Nan for -INF");
+
+            result = Math.Tan(double.PositiveInfinity);
+            Assert.IsTrue(double.IsNaN(result), "Tan returns Nan for INF");
+
+            result = Math.Tan(double.NaN);
+            Assert.IsTrue(double.IsNaN(result), "Tan returns Nan for Nan");
+
+            #endregion Math.Tan
+
+            #region Math.Atan
+
+            result = Math.Atan(0);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 0), "Atan works with 0");
+
+            result = Math.Atan(1);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 0.785398163397448), "Atan works with 1");
+
+            result = Math.Atan(-1);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, -0.785398163397448), "Atan works with -1");
+
+            result = Math.Atan(Math.PI);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 1.26262725567891), "Atan works with PI");
+
+            result = Math.Atan(Math.PI / 2);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 1.00388482185389), "Atan works with PI / 2");
+
+            result = Math.Atan(Math.PI / 3);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 0.808448792630022), "Atan works with PI / 3");
+
+            result = Math.Atan(double.NaN);
+            Assert.IsTrue(double.IsNaN(result), "Atan returns NaN for NaN");
+
+            result = Math.Atan(double.PositiveInfinity);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, 1.5707963267949), "Atan works with INF");
+
+            result = Math.Atan(double.NegativeInfinity);
+            Assert.IsTrue(EqualityHelper.DoublesAreEqual(result, -1.5707963267949), "Atan works with -INF");
+
+            #endregion Math.Atan
         }
     }
 }

source/Cosmos.Core_Plugs/System/BitConverterImpl.cs

@@ -115,7 +115,7 @@ namespace Cosmos.Core_Plugs.System
             {
                 if (startIndex % 2 == 0)
                 {
-                    // data is aligned 
+                    // data is aligned
                     return *((short*)pbyte);
                 }
                 else if (BitConverter.IsLittleEndian)
@@ -143,7 +143,7 @@ namespace Cosmos.Core_Plugs.System
             {
                 if (startIndex % 4 == 0)
                 {
-                    // data is aligned 
+                    // data is aligned
                     return *((int*)pbyte);
                 }
                 else if (BitConverter.IsLittleEndian)
@@ -171,7 +171,7 @@ namespace Cosmos.Core_Plugs.System
             {
                 if (startIndex % 8 == 0)
                 {
-                    // data is aligned 
+                    // data is aligned
                     return *((long*)pbyte);
                 }
                 else if (BitConverter.IsLittleEndian)
@@ -189,6 +189,20 @@ namespace Cosmos.Core_Plugs.System
             }
         }
 
+        public static unsafe double ToDouble(byte[] value, int startIndex)
+        {
+            if (value == null)
+                throw new ArgumentNullException("value");
+            if ((uint)startIndex > value.Length)
+                throw new ArgumentOutOfRangeException("startIndex");
+            if (startIndex > value.Length - 8)
+                throw new ArgumentException("Array with offset is too short");
+            Contract.EndContractBlock();
+
+            long val = ToInt64(value, startIndex);
+            return *(double*)&val;
+        }
+
         private static void ThrowValueArgumentNull()
         {
             throw new ArgumentNullException("value");

source/Cosmos.System2_Plugs/System/FloatImpl.cs

@@ -94,7 +94,6 @@ namespace Cosmos.System_Plugs.System
             {
                 parsed += fractionalDigits[i] * (float)Math.Pow(10, -1 * (i + 1));
             }
-
             parsed *= (float)Math.Pow(10, multiplier);
             parsed *= sign;