Merge pull request #84 from oliverbooth/feature/generic_math

Add support for generic math
oliverbooth · Jun 12, 2024 · b8a0671 · b8a0671
2 parents 8eaa01b + 7f92772
commit b8a0671
Show file tree

Hide file tree

Showing 39 changed files with 755 additions and 160 deletions.
diff --git a/X10D.Tests/src/IO/UInt16Tests.cs b/X10D.Tests/src/IO/UInt16Tests.cs
@@ -1,4 +1,4 @@
-using NUnit.Framework;
+using NUnit.Framework;
 using X10D.IO;
 
 namespace X10D.Tests.IO;

diff --git a/X10D.Tests/src/IO/UInt32Tests.cs b/X10D.Tests/src/IO/UInt32Tests.cs
@@ -1,4 +1,4 @@
-using NUnit.Framework;
+using NUnit.Framework;
 using X10D.IO;
 
 namespace X10D.Tests.IO;

diff --git a/X10D.Tests/src/IO/UInt64Tests.cs b/X10D.Tests/src/IO/UInt64Tests.cs
@@ -1,4 +1,4 @@
-using NUnit.Framework;
+using NUnit.Framework;
 using X10D.IO;
 
 namespace X10D.Tests.IO;

diff --git a/X10D.Tests/src/Math/ByteTests.cs b/X10D.Tests/src/Math/ByteTests.cs
@@ -51,13 +51,29 @@ public void CountDigits_ShouldReturn3_Given199()
     }
 
     [Test]
-    public void DigitalRootShouldBeCorrect()
+    public void DigitalRoot_ShouldReturn4_Given238()
     {
         const byte value = 238;
         Assert.That(value.DigitalRoot(), Is.EqualTo(4));
         Assert.That((-value).DigitalRoot(), Is.EqualTo(4));
     }
 
+    [Test]
+    public void DigitalRoot_ShouldReturn9_Given9()
+    {
+        const byte value = 9;
+        Assert.That(value.DigitalRoot(), Is.EqualTo(9));
+        Assert.That((-value).DigitalRoot(), Is.EqualTo(9));
+    }
+
+    [Test]
+    public void DigitalRoot_ShouldReturn9_Given18()
+    {
+        const byte value = 18;
+        Assert.That(value.DigitalRoot(), Is.EqualTo(9));
+        Assert.That((-value).DigitalRoot(), Is.EqualTo(9));
+    }
+
     [Test]
     public void FactorialShouldBeCorrect()
     {

diff --git a/X10D.Tests/src/Math/Int16Tests.cs b/X10D.Tests/src/Math/Int16Tests.cs
@@ -62,13 +62,29 @@ public void CountDigits_ShouldReturn3_Given199()
     }
 
     [Test]
-    public void DigitalRootShouldBeCorrect()
+    public void DigitalRoot_ShouldReturn4_Given238()
     {
         const short value = 238;
         Assert.That(value.DigitalRoot(), Is.EqualTo(4));
         Assert.That((-value).DigitalRoot(), Is.EqualTo(4));
     }
 
+    [Test]
+    public void DigitalRoot_ShouldReturn9_Given9()
+    {
+        const short value = 9;
+        Assert.That(value.DigitalRoot(), Is.EqualTo(9));
+        Assert.That((-value).DigitalRoot(), Is.EqualTo(9));
+    }
+
+    [Test]
+    public void DigitalRoot_ShouldReturn9_Given18()
+    {
+        const short value = 18;
+        Assert.That(value.DigitalRoot(), Is.EqualTo(9));
+        Assert.That((-value).DigitalRoot(), Is.EqualTo(9));
+    }
+
     [Test]
     public void FactorialShouldBeCorrect()
     {

diff --git a/X10D.Tests/src/Math/Int32Tests.cs b/X10D.Tests/src/Math/Int32Tests.cs
@@ -62,13 +62,29 @@ public void CountDigits_ShouldReturn3_Given199()
     }
 
     [Test]
-    public void DigitalRootShouldBeCorrect()
+    public void DigitalRoot_ShouldReturn4_Given238()
     {
         const int value = 238;
         Assert.That(value.DigitalRoot(), Is.EqualTo(4));
         Assert.That((-value).DigitalRoot(), Is.EqualTo(4));
     }
 
+    [Test]
+    public void DigitalRoot_ShouldReturn9_Given9()
+    {
+        const int value = 9;
+        Assert.That(value.DigitalRoot(), Is.EqualTo(9));
+        Assert.That((-value).DigitalRoot(), Is.EqualTo(9));
+    }
+
+    [Test]
+    public void DigitalRoot_ShouldReturn9_Given18()
+    {
+        const int value = 18;
+        Assert.That(value.DigitalRoot(), Is.EqualTo(9));
+        Assert.That((-value).DigitalRoot(), Is.EqualTo(9));
+    }
+
     [Test]
     public void FactorialShouldBeCorrect()
     {

diff --git a/X10D.Tests/src/Math/Int64Tests.cs b/X10D.Tests/src/Math/Int64Tests.cs
@@ -62,13 +62,29 @@ public void CountDigits_ShouldReturn3_Given199()
     }
 
     [Test]
-    public void DigitalRootShouldBeCorrect()
+    public void DigitalRoot_ShouldReturn4_Given238()
     {
         const long value = 238;
         Assert.That(value.DigitalRoot(), Is.EqualTo(4));
         Assert.That((-value).DigitalRoot(), Is.EqualTo(4));
     }
 
+    [Test]
+    public void DigitalRoot_ShouldReturn9_Given9()
+    {
+        const long value = 9;
+        Assert.That(value.DigitalRoot(), Is.EqualTo(9));
+        Assert.That((-value).DigitalRoot(), Is.EqualTo(9));
+    }
+
+    [Test]
+    public void DigitalRoot_ShouldReturn9_Given18()
+    {
+        const long value = 18;
+        Assert.That(value.DigitalRoot(), Is.EqualTo(9));
+        Assert.That((-value).DigitalRoot(), Is.EqualTo(9));
+    }
+
     [Test]
     public void FactorialShouldBeCorrect()
     {

diff --git a/X10D.Tests/src/Math/SByteTests.cs b/X10D.Tests/src/Math/SByteTests.cs
@@ -62,13 +62,29 @@ public void CountDigits_ShouldReturn3_Given127()
     }
 
     [Test]
-    public void DigitalRootShouldBeCorrect()
+    public void DigitalRoot_ShouldReturn4_Given127()
     {
         const sbyte value = 127; // sbyte.MaxValue. can't use 238 like the other tests
         Assert.That(value.DigitalRoot(), Is.EqualTo(1));
         Assert.That((-value).DigitalRoot(), Is.EqualTo(1));
     }
 
+    [Test]
+    public void DigitalRoot_ShouldReturn9_Given9()
+    {
+        const sbyte value = 9;
+        Assert.That(value.DigitalRoot(), Is.EqualTo(9));
+        Assert.That((-value).DigitalRoot(), Is.EqualTo(9));
+    }
+
+    [Test]
+    public void DigitalRoot_ShouldReturn9_Given18()
+    {
+        const sbyte value = 18;
+        Assert.That(value.DigitalRoot(), Is.EqualTo(9));
+        Assert.That((-value).DigitalRoot(), Is.EqualTo(9));
+    }
+
     [Test]
     public void FactorialShouldBeCorrect()
     {

diff --git a/X10D.Tests/src/Math/UInt16Tests.cs b/X10D.Tests/src/Math/UInt16Tests.cs
@@ -51,13 +51,29 @@ public void CountDigits_ShouldReturn3_Given199()
     }
 
     [Test]
-    public void DigitalRootShouldBeCorrect()
+    public void DigitalRoot_ShouldReturn4_Given238()
     {
         const ushort value = 238;
         Assert.That(value.DigitalRoot(), Is.EqualTo(4));
         Assert.That((-value).DigitalRoot(), Is.EqualTo(4));
     }
 
+    [Test]
+    public void DigitalRoot_ShouldReturn9_Given9()
+    {
+        const ushort value = 9;
+        Assert.That(value.DigitalRoot(), Is.EqualTo(9));
+        Assert.That((-value).DigitalRoot(), Is.EqualTo(9));
+    }
+
+    [Test]
+    public void DigitalRoot_ShouldReturn9_Given18()
+    {
+        const ushort value = 18;
+        Assert.That(value.DigitalRoot(), Is.EqualTo(9));
+        Assert.That((-value).DigitalRoot(), Is.EqualTo(9));
+    }
+
     [Test]
     public void FactorialShouldBeCorrect()
     {

diff --git a/X10D.Tests/src/Math/UInt32Tests.cs b/X10D.Tests/src/Math/UInt32Tests.cs
@@ -1,4 +1,4 @@
-using NUnit.Framework;
+using NUnit.Framework;
 using X10D.Math;
 
 namespace X10D.Tests.Math;
@@ -50,11 +50,27 @@ public void CountDigits_ShouldReturn3_Given199()
     }
 
     [Test]
-    public void DigitalRootShouldBeCorrect()
+    public void DigitalRoot_ShouldReturn4_Given238()
     {
         const uint value = 238;
-        Assert.That(value.DigitalRoot(), Is.EqualTo(4U));
-        Assert.That((-value).DigitalRoot(), Is.EqualTo(4U));
+        Assert.That(value.DigitalRoot(), Is.EqualTo(4));
+        Assert.That((-value).DigitalRoot(), Is.EqualTo(4));
+    }
+
+    [Test]
+    public void DigitalRoot_ShouldReturn9_Given9()
+    {
+        const uint value = 9;
+        Assert.That(value.DigitalRoot(), Is.EqualTo(9));
+        Assert.That((-value).DigitalRoot(), Is.EqualTo(9));
+    }
+
+    [Test]
+    public void DigitalRoot_ShouldReturn9_Given18()
+    {
+        const uint value = 18;
+        Assert.That(value.DigitalRoot(), Is.EqualTo(9));
+        Assert.That((-value).DigitalRoot(), Is.EqualTo(9));
     }
 
     [Test]

diff --git a/X10D.Tests/src/Math/UInt64Tests.cs b/X10D.Tests/src/Math/UInt64Tests.cs
@@ -1,4 +1,4 @@
-using NUnit.Framework;
+using NUnit.Framework;
 using X10D.Math;
 
 namespace X10D.Tests.Math;
@@ -51,15 +51,31 @@ public void CountDigits_ShouldReturn3_Given199()
     }
 
     [Test]
-    public void DigitalRootShouldBeCorrect()
+    public void DigitalRoot_ShouldReturn4_Given238()
     {
         const ulong value = 238;
-        Assert.That(value.DigitalRoot(), Is.EqualTo(4U));
+        Assert.That(value.DigitalRoot(), Is.EqualTo(4));
 
         // -ulong operator not defined because it might exceed long.MinValue,
         // so instead, cast to long and then negate.
         // HAX.
-        Assert.That((-(long)value).DigitalRoot(), Is.EqualTo(4U));
+        Assert.That((-(long)value).DigitalRoot(), Is.EqualTo(4));
+    }
+
+    [Test]
+    public void DigitalRoot_ShouldReturn9_Given9()
+    {
+        const ulong value = 9;
+        Assert.That(value.DigitalRoot(), Is.EqualTo(9));
+        Assert.That((-(long)value).DigitalRoot(), Is.EqualTo(9));
+    }
+
+    [Test]
+    public void DigitalRoot_ShouldReturn9_Given18()
+    {
+        const ulong value = 18;
+        Assert.That(value.DigitalRoot(), Is.EqualTo(9));
+        Assert.That((-(long)value).DigitalRoot(), Is.EqualTo(9));
     }
 
     [Test]

diff --git a/X10D.Tests/src/Numerics/NumberTests.cs b/X10D.Tests/src/Numerics/NumberTests.cs
@@ -0,0 +1,32 @@
+#if NET7_0_OR_GREATER
+using NUnit.Framework;
+using X10D.Math;
+
+namespace X10D.Tests.Numerics;
+
+[TestFixture]
+internal class NumberTests
+{
+    [Test]
+    public void Sign_ShouldReturn1_GivenPositiveNumber()
+    {
+        Assert.That(NumberExtensions.Sign(2), Is.Positive);
+        Assert.That(NumberExtensions.Sign(2), Is.EqualTo(1));
+    }
+
+    [Test]
+    public void Sign_Should0_GivenZero()
+    {
+        Assert.That(NumberExtensions.Sign(0), Is.Not.Positive);
+        Assert.That(NumberExtensions.Sign(0), Is.Not.Negative);
+        Assert.That(NumberExtensions.Sign(0), Is.EqualTo(0));
+    }
+
+    [Test]
+    public void Sign_ShouldReturnNegative1_GivenNegativeNumber()
+    {
+        Assert.That(NumberExtensions.Sign(-2), Is.Negative);
+        Assert.That(NumberExtensions.Sign(-2), Is.EqualTo(-1));
+    }
+}
+#endif