Add tests for IsEven/IsOdd/DigitalRoot

X10D.Tests/src/Math/ByteTests.cs

@@ -6,6 +6,14 @@ namespace X10D.Tests.Math;
 [TestClass]
 public class ByteTests
 {
+    [TestMethod]
+    public void DigitalRootShouldBeCorrect()
+    {
+        const byte value = 238;
+        Assert.AreEqual(4, value.DigitalRoot());
+        Assert.AreEqual(4, (-value).DigitalRoot());
+    }
+
     [TestMethod]
     public void FactorialShouldBeCorrect()
     {
@@ -28,11 +36,8 @@ public class ByteTests
         const byte one = 1;
         const byte two = 2;
 
-        bool oneEven = one.IsEven();
+        Assert.IsFalse(one.IsEven());
-        bool twoEven = two.IsEven();
+        Assert.IsTrue(two.IsEven());
-
-        Assert.IsFalse(oneEven);
-        Assert.IsTrue(twoEven);
     }
 
     [TestMethod]
@@ -41,10 +46,7 @@ public class ByteTests
         const byte one = 1;
         const byte two = 2;
 
-        bool oneOdd = one.IsOdd();
+        Assert.IsTrue(one.IsOdd());
-        bool twoOdd = two.IsOdd();
+        Assert.IsFalse(two.IsOdd());
-
-        Assert.IsTrue(oneOdd);
-        Assert.IsFalse(twoOdd);
     }
 }

X10D.Tests/src/Math/Int16Tests.cs

@@ -6,6 +6,14 @@ namespace X10D.Tests.Math;
 [TestClass]
 public class Int16Tests
 {
+    [TestMethod]
+    public void DigitalRootShouldBeCorrect()
+    {
+        const short value = 238;
+        Assert.AreEqual(4, value.DigitalRoot());
+        Assert.AreEqual(4, (-value).DigitalRoot());
+    }
+
     [TestMethod]
     public void FactorialShouldBeCorrect()
     {
@@ -22,9 +30,39 @@ public class Int16Tests
         Assert.AreEqual(3628800L, ((short)10).Factorial());
     }
 
+    [TestMethod]
+    public void IsEvenShouldBeCorrect()
+    {
+        const short one = 1;
+        const short two = 2;
+        
+        Assert.IsFalse(one.IsEven());
+        Assert.IsTrue(two.IsEven());
+    }
+
+    [TestMethod]
+    public void IsOddShouldBeCorrect()
+    {
+        const short one = 1;
+        const short two = 2;
+        
+        Assert.IsTrue(one.IsOdd());
+        Assert.IsFalse(two.IsOdd());
+    }
+
     [TestMethod]
     public void NegativeFactorialShouldThrow()
     {
         Assert.ThrowsException<ArithmeticException>(() => ((short)-1).Factorial());
     }
+
+    [TestMethod]
+    public void SignShouldBeCorrect()
+    {
+        const short one = 1;
+        const short zero = 0;
+        Assert.AreEqual(one, one.Sign());
+        Assert.AreEqual(zero, zero.Sign());
+        Assert.AreEqual(-one, (-one).Sign());
+    }
 }

X10D.Tests/src/Math/Int32Tests.cs

@@ -6,6 +6,14 @@ namespace X10D.Tests.Math;
 [TestClass]
 public class Int32Tests
 {
+    [TestMethod]
+    public void DigitalRootShouldBeCorrect()
+    {
+        const int value = 238;
+        Assert.AreEqual(4, value.DigitalRoot());
+        Assert.AreEqual(4, (-value).DigitalRoot());
+    }
+
     [TestMethod]
     public void FactorialShouldBeCorrect()
     {
@@ -22,9 +30,39 @@ public class Int32Tests
         Assert.AreEqual(3628800L, 10.Factorial());
     }
 
+    [TestMethod]
+    public void IsEvenShouldBeCorrect()
+    {
+        const int one = 1;
+        const int two = 2;
+        
+        Assert.IsFalse(one.IsEven());
+        Assert.IsTrue(two.IsEven());
+    }
+
+    [TestMethod]
+    public void IsOddShouldBeCorrect()
+    {
+        const int one = 1;
+        const int two = 2;
+        
+        Assert.IsTrue(one.IsOdd());
+        Assert.IsFalse(two.IsOdd());
+    }
+
     [TestMethod]
     public void NegativeFactorialShouldThrow()
     {
         Assert.ThrowsException<ArithmeticException>(() => (-1).Factorial());
     }
+
+    [TestMethod]
+    public void SignShouldBeCorrect()
+    {
+        const int one = 1;
+        const int zero = 0;
+        Assert.AreEqual(one, one.Sign());
+        Assert.AreEqual(zero, zero.Sign());
+        Assert.AreEqual(-one, (-one).Sign());
+    }
 }

X10D.Tests/src/Math/Int64Tests.cs

@@ -6,6 +6,14 @@ namespace X10D.Tests.Math;
 [TestClass]
 public class Int64Tests
 {
+    [TestMethod]
+    public void DigitalRootShouldBeCorrect()
+    {
+        const long value = 238;
+        Assert.AreEqual(4, value.DigitalRoot());
+        Assert.AreEqual(4, (-value).DigitalRoot());
+    }
+
     [TestMethod]
     public void FactorialShouldBeCorrect()
     {
@@ -22,9 +30,39 @@ public class Int64Tests
         Assert.AreEqual(3628800L, 10L.Factorial());
     }
 
+    [TestMethod]
+    public void IsEvenShouldBeCorrect()
+    {
+        const long one = 1;
+        const long two = 2;
+        
+        Assert.IsFalse(one.IsEven());
+        Assert.IsTrue(two.IsEven());
+    }
+
+    [TestMethod]
+    public void IsOddShouldBeCorrect()
+    {
+        const long one = 1;
+        const long two = 2;
+        
+        Assert.IsTrue(one.IsOdd());
+        Assert.IsFalse(two.IsOdd());
+    }
+
     [TestMethod]
     public void NegativeFactorialShouldThrow()
     {
         Assert.ThrowsException<ArithmeticException>(() => (-1L).Factorial());
     }
+
+    [TestMethod]
+    public void SignShouldBeCorrect()
+    {
+        const long one = 1;
+        const long zero = 0;
+        Assert.AreEqual(one, one.Sign());
+        Assert.AreEqual(zero, zero.Sign());
+        Assert.AreEqual(-one, (-one).Sign());
+    }
 }

X10D.Tests/src/Math/SByteTests.cs

@@ -7,6 +7,14 @@ namespace X10D.Tests.Math;
 [CLSCompliant(false)]
 public class SByteTests
 {
+    [TestMethod]
+    public void DigitalRootShouldBeCorrect()
+    {
+        const sbyte value = 127; // sbyte.MaxValue. can't use 238 like the other tests
+        Assert.AreEqual(1, value.DigitalRoot());
+        Assert.AreEqual(1, (-value).DigitalRoot());
+    }
+    
     [TestMethod]
     public void FactorialShouldBeCorrect()
     {
@@ -28,12 +36,9 @@ public class SByteTests
     {
         const sbyte one = 1;
         const sbyte two = 2;
-
+        
-        bool oneEven = one.IsEven();
+        Assert.IsFalse(one.IsEven());
-        bool twoEven = two.IsEven();
+        Assert.IsTrue(two.IsEven());
-
-        Assert.AreEqual(false, oneEven);
-        Assert.AreEqual(true, twoEven);
     }
 
     [TestMethod]
@@ -41,12 +46,9 @@ public class SByteTests
     {
         const sbyte one = 1;
         const sbyte two = 2;
-
+        
-        bool oneOdd = one.IsOdd();
+        Assert.IsTrue(one.IsOdd());
-        bool twoOdd = two.IsOdd();
+        Assert.IsFalse(two.IsOdd());
-
-        Assert.AreEqual(true, oneOdd);
-        Assert.AreEqual(false, twoOdd);
     }
 
     [TestMethod]
@@ -54,4 +56,14 @@ public class SByteTests
     {
         Assert.ThrowsException<ArithmeticException>(() => ((sbyte)-1).Factorial());
     }
+
+    [TestMethod]
+    public void SignShouldBeCorrect()
+    {
+        const sbyte one = 1;
+        const sbyte zero = 0;
+        Assert.AreEqual(one, one.Sign());
+        Assert.AreEqual(zero, zero.Sign());
+        Assert.AreEqual(-one, (-one).Sign());
+    }
 }

X10D.Tests/src/Math/UInt16Tests.cs

@@ -7,6 +7,14 @@ namespace X10D.Tests.Math;
 [CLSCompliant(false)]
 public class UInt16Tests
 {
+    [TestMethod]
+    public void DigitalRootShouldBeCorrect()
+    {
+        const ushort value = 238;
+        Assert.AreEqual(4, value.DigitalRoot());
+        Assert.AreEqual(4, (-value).DigitalRoot());
+    }
+    
     [TestMethod]
     public void FactorialShouldBeCorrect()
     {
@@ -22,4 +30,24 @@ public class UInt16Tests
         Assert.AreEqual(362880UL, ((ushort)9).Factorial());
         Assert.AreEqual(3628800UL, ((ushort)10).Factorial());
     }
+
+    [TestMethod]
+    public void IsEvenShouldBeCorrect()
+    {
+        const ushort one = 1;
+        const ushort two = 2;
+        
+        Assert.IsFalse(one.IsEven());
+        Assert.IsTrue(two.IsEven());
+    }
+
+    [TestMethod]
+    public void IsOddShouldBeCorrect()
+    {
+        const ushort one = 1;
+        const ushort two = 2;
+        
+        Assert.IsTrue(one.IsOdd());
+        Assert.IsFalse(two.IsOdd());
+    }
 }

X10D.Tests/src/Math/UInt32Tests.cs

@@ -7,6 +7,14 @@ namespace X10D.Tests.Math;
 [CLSCompliant(false)]
 public class UInt32Tests
 {
+    [TestMethod]
+    public void DigitalRootShouldBeCorrect()
+    {
+        const uint value = 238;
+        Assert.AreEqual(4U, value.DigitalRoot());
+        Assert.AreEqual(4U, (-value).DigitalRoot());
+    }
+
     [TestMethod]
     public void FactorialShouldBeCorrect()
     {
@@ -22,4 +30,24 @@ public class UInt32Tests
         Assert.AreEqual(362880UL, 9U.Factorial());
         Assert.AreEqual(3628800UL, 10U.Factorial());
     }
+
+    [TestMethod]
+    public void IsEvenShouldBeCorrect()
+    {
+        const uint one = 1;
+        const uint two = 2;
+        
+        Assert.IsFalse(one.IsEven());
+        Assert.IsTrue(two.IsEven());
+    }
+
+    [TestMethod]
+    public void IsOddShouldBeCorrect()
+    {
+        const uint one = 1;
+        const uint two = 2;
+        
+        Assert.IsTrue(one.IsOdd());
+        Assert.IsFalse(two.IsOdd());
+    }
 }

X10D.Tests/src/Math/UInt64Tests.cs

@@ -7,6 +7,18 @@ namespace X10D.Tests.Math;
 [CLSCompliant(false)]
 public class UInt64Tests
 {
+    [TestMethod]
+    public void DigitalRootShouldBeCorrect()
+    {
+        const ulong value = 238;
+        Assert.AreEqual(4U, value.DigitalRoot());
+
+        // -ulong operator not defined because it might exceed long.MinValue,
+        // so instead, cast to long and then negate.
+        // HAX.
+        Assert.AreEqual(4U, (-(long)value).DigitalRoot());
+    }
+
     [TestMethod]
     public void FactorialShouldBeCorrect()
     {
@@ -22,4 +34,24 @@ public class UInt64Tests
         Assert.AreEqual(362880UL, 9UL.Factorial());
         Assert.AreEqual(3628800UL, 10UL.Factorial());
     }
+
+    [TestMethod]
+    public void IsEvenShouldBeCorrect()
+    {
+        const ulong one = 1;
+        const ulong two = 2;
+        
+        Assert.IsFalse(one.IsEven());
+        Assert.IsTrue(two.IsEven());
+    }
+
+    [TestMethod]
+    public void IsOddShouldBeCorrect()
+    {
+        const ulong one = 1;
+        const ulong two = 2;
+        
+        Assert.IsTrue(one.IsOdd());
+        Assert.IsFalse(two.IsOdd());
+    }
 }

X10D/src/Int16Extensions/Int16Extensions.cs

@@ -10,56 +10,6 @@ namespace X10D;
 /// </summary>
 public static class Int16Extensions
 {
-    /// <summary>
-    ///     Computes the digital root of an integer.
-    /// </summary>
-    /// <param name="value">The value whose digital root to compute.</param>
-    /// <returns>The digital root of <paramref name="value" />.</returns>
-    /// <remarks>The digital root is defined as the recursive sum of digits until that result is a single digit.</remarks>
-    public static short DigitalRoot(this short value)
-    {
-        short root = value.Mod(9);
-        return root < 1 ? (short)(9 - root) : root;
-    }
-
-    /// <summary>
-    ///     Converts a Unix time expressed as the number of milliseconds that have elapsed since 1970-01-01T00:00:00Z to a
-    ///     <see cref="DateTimeOffset" /> value.
-    /// </summary>
-    /// <param name="value">
-    ///     A Unix time, expressed as the number of milliseconds that have elapsed since 1970-01-01T00:00:00Z (January 1, 1970, at
-    ///     12:00 AM UTC). For Unix times before this date, its value is negative.
-    /// </param>
-    /// <returns>A date and time value that represents the same moment in time as the Unix time.</returns>
-    /// <exception cref="ArgumentOutOfRangeException">
-    ///     <para><paramref name="value" /> is less than -62,135,596,800,000.</para>
-    ///     -or-
-    ///     <para><paramref name="value" /> is greater than 253,402,300,799,999.</para>
-    /// </exception>
-    public static DateTimeOffset FromUnixTimeMilliseconds(this short value)
-    {
-        return DateTimeOffset.FromUnixTimeMilliseconds(value);
-    }
-
-    /// <summary>
-    ///     Converts a Unix time expressed as the number of seconds that have elapsed since 1970-01-01T00:00:00Z to a
-    ///     <see cref="DateTimeOffset" /> value.
-    /// </summary>
-    /// <param name="value">
-    ///     A Unix time, expressed as the number of seconds that have elapsed since 1970-01-01T00:00:00Z (January 1, 1970, at
-    ///     12:00 AM UTC). For Unix times before this date, its value is negative.
-    /// </param>
-    /// <returns>A date and time value that represents the same moment in time as the Unix time.</returns>
-    /// <exception cref="ArgumentOutOfRangeException">
-    ///     <para><paramref name="value" /> is less than -62,135,596,800.</para>
-    ///     -or-
-    ///     <para><paramref name="value" /> is greater than 253,402,300,799.</para>
-    /// </exception>
-    public static DateTimeOffset FromUnixTimeSeconds(this short value)
-    {
-        return DateTimeOffset.FromUnixTimeSeconds(value);
-    }
-
     /// <summary>
     ///     Returns the current 16-bit signed integer value as an array of bytes.
     /// </summary>
@@ -70,182 +20,6 @@ public static class Int16Extensions
         return BitConverter.GetBytes(value);
     }
 
-    /// <summary>
-    ///     Returns a value indicating whether the current value is evenly divisible by 2.
-    /// </summary>
-    /// <param name="value">The value whose parity to check.</param>
-    /// <returns>
-    ///     <see langword="true" /> if <paramref name="value" /> is evenly divisible by 2, or <see langword="false" />
-    ///     otherwise.
-    /// </returns>
-    public static bool IsEven(this short value)
-    {
-        return (value & 1) == 0;
-    }
-
-    /// <summary>
-    ///     Returns a value indicating whether the current value is not evenly divisible by 2.
-    /// </summary>
-    /// <param name="value">The value whose parity to check.</param>
-    /// <returns>
-    ///     <see langword="true" /> if <paramref name="value" /> is not evenly divisible by 2, or <see langword="false" />
-    ///     otherwise.
-    /// </returns>
-    public static bool IsOdd(this short value)
-    {
-        return !value.IsEven();
-    }
-
-    /// <summary>
-    ///     Returns a value indicating whether the current value is a prime number.
-    /// </summary>
-    /// <param name="value">The value whose primality to check.</param>
-    /// <returns>
-    ///     <see langword="true" /> if <paramref name="value" /> is prime; otherwise, <see langword="false" />.
-    /// </returns>
-    public static bool IsPrime(this short value)
-    {
-        return ((long)value).IsPrime();
-    }
-
-    /// <summary>
-    ///     Linearly interpolates to the current value from a specified source using a specified alpha.
-    /// </summary>
-    /// <param name="target">The interpolation target.</param>
-    /// <param name="value">The interpolation source.</param>
-    /// <param name="alpha">The interpolation alpha.</param>
-    /// <returns>
-    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
-    /// </returns>
-    public static double LerpFrom(this short target, double value, double alpha)
-    {
-        return MathUtility.Lerp(value, target, alpha);
-    }
-
-    /// <summary>
-    ///     Linearly interpolates to the current value from a specified source using a specified alpha.
-    /// </summary>
-    /// <param name="target">The interpolation target.</param>
-    /// <param name="value">The interpolation source.</param>
-    /// <param name="alpha">The interpolation alpha.</param>
-    /// <returns>
-    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
-    /// </returns>
-    public static float LerpFrom(this short target, float value, float alpha)
-    {
-        return MathUtility.Lerp(value, target, alpha);
-    }
-
-    /// <summary>
-    ///     Linearly interpolates from the current value to a specified target using a specified alpha.
-    /// </summary>
-    /// <param name="value">The interpolation source.</param>
-    /// <param name="target">The interpolation target.</param>
-    /// <param name="alpha">The interpolation alpha.</param>
-    /// <returns>
-    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
-    /// </returns>
-    public static double LerpTo(this short value, double target, double alpha)
-    {
-        return MathUtility.Lerp(value, target, alpha);
-    }
-
-    /// <summary>
-    ///     Linearly interpolates from the current value to a specified target using a specified alpha.
-    /// </summary>
-    /// <param name="value">The interpolation source.</param>
-    /// <param name="target">The interpolation target.</param>
-    /// <param name="alpha">The interpolation alpha.</param>
-    /// <returns>
-    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
-    /// </returns>
-    public static float LerpTo(this short value, float target, float alpha)
-    {
-        return MathUtility.Lerp(value, target, alpha);
-    }
-
-    /// <summary>
-    ///     Linearly interpolates to a specified target from a specified source, using the current value as the alpha value.
-    /// </summary>
-    /// <param name="alpha">The interpolation alpha.</param>
-    /// <param name="value">The interpolation source.</param>
-    /// <param name="target">The interpolation target.</param>
-    /// <returns>
-    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
-    /// </returns>
-    public static double LerpWith(this short alpha, double value, double target)
-    {
-        return MathUtility.Lerp(value, target, alpha);
-    }
-
-    /// <summary>
-    ///     Linearly interpolates to a specified target from a specified source, using the current value as the alpha value.
-    /// </summary>
-    /// <param name="alpha">The interpolation alpha.</param>
-    /// <param name="value">The interpolation source.</param>
-    /// <param name="target">The interpolation target.</param>
-    /// <returns>
-    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
-    /// </returns>
-    public static float LerpWith(this short alpha, float value, float target)
-    {
-        return MathUtility.Lerp(value, target, alpha);
-    }
-
-    /// <summary>
-    ///     Performs a modulo operation which supports a negative dividend.
-    /// </summary>
-    /// <param name="dividend">The dividend.</param>
-    /// <param name="divisor">The divisor.</param>
-    /// <returns>The result of <c>dividend mod divisor</c>.</returns>
-    /// <remarks>
-    ///     The <c>%</c> operator (commonly called the modulo operator) in C# is not defined to be modulo, but is instead
-    ///     remainder. This quirk inherently makes it difficult to use modulo in a negative context, as <c>x % y</c> where x is
-    ///     negative will return a negative value, akin to <c>-(x % y)</c>, even if precedence is forced. This method provides a
-    ///     modulo operation which supports negative dividends.
-    /// </remarks>
-    /// <author>ShreevatsaR, https://stackoverflow.com/a/1082938/1467293</author>
-    /// <license>CC-BY-SA 2.5</license>
-    public static short Mod(this short dividend, short divisor)
-    {
-        var r = (short)(dividend % divisor);
-        return (short)(r < 0 ? r + divisor : r);
-    }
-
-    /// <summary>
-    ///     Returns an integer that indicates the sign of this 16-bit signed integer.
-    /// </summary>
-    /// <param name="value">A signed number.</param>
-    /// <returns>
-    ///     A number that indicates the sign of <paramref name="value" />, as shown in the following table.
-    ///
-    ///     <list type="table">
-    ///         <listheader>
-    ///             <term>Return value</term>
-    ///             <description>Meaning</description>
-    ///         </listheader>
-    ///
-    ///         <item>
-    ///             <term>-1</term>
-    ///             <description><paramref name="value" /> is less than zero.</description>
-    ///         </item>
-    ///         <item>
-    ///             <term>0</term>
-    ///             <description><paramref name="value" /> is equal to zero.</description>
-    ///         </item>
-    ///         <item>
-    ///             <term>1</term>
-    ///             <description><paramref name="value" /> is greater than zero.</description>
-    ///         </item>
-    ///     </list>
-    /// </returns>
-    [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-    public static int Sign(this short value)
-    {
-        return System.Math.Sign(value);
-    }
-
     /// <summary>
     ///     Returns an enumerable collection of 16-bit signed integers that range from the current value to a specified value.
     /// </summary>

X10D/src/Int32Extensions/Int32Extensions.cs

@@ -1,4 +1,4 @@
-using System.Diagnostics.Contracts;
+using System.Diagnostics.Contracts;
 using System.Net;
 using System.Runtime.CompilerServices;
 using X10D.Math;
@@ -63,53 +63,13 @@ public static class Int32Extensions
     }
 
     /// <summary>
-    ///     Computes the digital root of an integer.
+    ///     Converts the current angle in degrees to its equivalent represented in radians.
     /// </summary>
-    /// <param name="value">The value whose digital root to compute.</param>
+    /// <param name="value">The angle in degrees to convert.</param>
-    /// <returns>The digital root of <paramref name="value" />.</returns>
+    /// <returns>The result of π * <paramref name="value" /> / 180.</returns>
-    /// <remarks>The digital root is defined as the recursive sum of digits until that result is a single digit.</remarks>
+    public static float DegreesToRadians(this int value)
-    public static int DigitalRoot(this int value)
     {
-        int root = value.Mod(9);
+        return ((float)value).DegreesToRadians();
-        return root < 1 ? 9 - root : root;
-    }
-
-    /// <summary>
-    ///     Converts a Unix time expressed as the number of milliseconds that have elapsed since 1970-01-01T00:00:00Z to a
-    ///     <see cref="DateTimeOffset" /> value.
-    /// </summary>
-    /// <param name="value">
-    ///     A Unix time, expressed as the number of milliseconds that have elapsed since 1970-01-01T00:00:00Z (January 1,
-    ///     1970, at 12:00 AM UTC). For Unix times before this date, its value is negative.
-    /// </param>
-    /// <returns>A date and time value that represents the same moment in time as the Unix time.</returns>
-    /// <exception cref="ArgumentOutOfRangeException">
-    ///     <para><paramref name="value" /> is less than -62,135,596,800,000.</para>
-    ///     -or-
-    ///     <para><paramref name="value" /> is greater than 253,402,300,799,999.</para>
-    /// </exception>
-    public static DateTimeOffset FromUnixTimeMilliseconds(this int value)
-    {
-        return DateTimeOffset.FromUnixTimeMilliseconds(value);
-    }
-
-    /// <summary>
-    ///     Converts a Unix time expressed as the number of seconds that have elapsed since 1970-01-01T00:00:00Z to a
-    ///     <see cref="DateTimeOffset" /> value.
-    /// </summary>
-    /// <param name="value">
-    ///     A Unix time, expressed as the number of seconds that have elapsed since 1970-01-01T00:00:00Z (January 1, 1970, at
-    ///     12:00 AM UTC). For Unix times before this date, its value is negative.
-    /// </param>
-    /// <returns>A date and time value that represents the same moment in time as the Unix time.</returns>
-    /// <exception cref="ArgumentOutOfRangeException">
-    ///     <para><paramref name="value" /> is less than -62,135,596,800.</para>
-    ///     -or-
-    ///     <para><paramref name="value" /> is greater than 253,402,300,799.</para>
-    /// </exception>
-    public static DateTimeOffset FromUnixTimeSeconds(this int value)
-    {
-        return DateTimeOffset.FromUnixTimeSeconds(value);
     }
 
     /// <summary>
@@ -122,148 +82,6 @@ public static class Int32Extensions
         return BitConverter.GetBytes(value);
     }
 
-    /// <summary>
-    ///     Returns a value indicating whether the current value is evenly divisible by 2.
-    /// </summary>
-    /// <param name="value">The value whose parity to check.</param>
-    /// <returns>
-    ///     <see langword="true" /> if <paramref name="value" /> is evenly divisible by 2, or <see langword="false" />
-    ///     otherwise.
-    /// </returns>
-    public static bool IsEven(this int value)
-    {
-        return (value & 1) == 0;
-    }
-
-    /// <summary>
-    ///     Returns a value indicating whether the current value is not evenly divisible by 2.
-    /// </summary>
-    /// <param name="value">The value whose parity to check.</param>
-    /// <returns>
-    ///     <see langword="true" /> if <paramref name="value" /> is not evenly divisible by 2, or <see langword="false" />
-    ///     otherwise.
-    /// </returns>
-    public static bool IsOdd(this int value)
-    {
-        return !value.IsEven();
-    }
-
-    /// <summary>
-    ///     Returns a value indicating whether the current value is a prime number.
-    /// </summary>
-    /// <param name="value">The value whose primality to check.</param>
-    /// <returns>
-    ///     <see langword="true" /> if <paramref name="value" /> is prime; otherwise, <see langword="false" />.
-    /// </returns>
-    public static bool IsPrime(this int value)
-    {
-        return ((long)value).IsPrime();
-    }
-
-    /// <summary>
-    ///     Linearly interpolates to the current value from a specified source using a specified alpha.
-    /// </summary>
-    /// <param name="target">The interpolation target.</param>
-    /// <param name="value">The interpolation source.</param>
-    /// <param name="alpha">The interpolation alpha.</param>
-    /// <returns>
-    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
-    /// </returns>
-    public static double LerpFrom(this int target, double value, double alpha)
-    {
-        return MathUtility.Lerp(value, target, alpha);
-    }
-
-    /// <summary>
-    ///     Linearly interpolates to the current value from a specified source using a specified alpha.
-    /// </summary>
-    /// <param name="target">The interpolation target.</param>
-    /// <param name="value">The interpolation source.</param>
-    /// <param name="alpha">The interpolation alpha.</param>
-    /// <returns>
-    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
-    /// </returns>
-    public static float LerpFrom(this int target, float value, float alpha)
-    {
-        return MathUtility.Lerp(value, target, alpha);
-    }
-
-    /// <summary>
-    ///     Linearly interpolates from the current value to a specified target using a specified alpha.
-    /// </summary>
-    /// <param name="value">The interpolation source.</param>
-    /// <param name="target">The interpolation target.</param>
-    /// <param name="alpha">The interpolation alpha.</param>
-    /// <returns>
-    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
-    /// </returns>
-    public static double LerpTo(this int value, double target, double alpha)
-    {
-        return MathUtility.Lerp(value, target, alpha);
-    }
-
-    /// <summary>
-    ///     Linearly interpolates from the current value to a specified target using a specified alpha.
-    /// </summary>
-    /// <param name="value">The interpolation source.</param>
-    /// <param name="target">The interpolation target.</param>
-    /// <param name="alpha">The interpolation alpha.</param>
-    /// <returns>
-    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
-    /// </returns>
-    public static float LerpTo(this int value, float target, float alpha)
-    {
-        return MathUtility.Lerp(value, target, alpha);
-    }
-
-    /// <summary>
-    ///     Linearly interpolates to a specified target from a specified source, using the current value as the alpha value.
-    /// </summary>
-    /// <param name="alpha">The interpolation alpha.</param>
-    /// <param name="value">The interpolation source.</param>
-    /// <param name="target">The interpolation target.</param>
-    /// <returns>
-    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
-    /// </returns>
-    public static double LerpWith(this int alpha, double value, double target)
-    {
-        return MathUtility.Lerp(value, target, alpha);
-    }
-
-    /// <summary>
-    ///     Linearly interpolates to a specified target from a specified source, using the current value as the alpha value.
-    /// </summary>
-    /// <param name="alpha">The interpolation alpha.</param>
-    /// <param name="value">The interpolation source.</param>
-    /// <param name="target">The interpolation target.</param>
-    /// <returns>
-    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
-    /// </returns>
-    public static float LerpWith(this int alpha, float value, float target)
-    {
-        return MathUtility.Lerp(value, target, alpha);
-    }
-
-    /// <summary>
-    ///     Performs a modulo operation which supports a negative dividend.
-    /// </summary>
-    /// <param name="dividend">The dividend.</param>
-    /// <param name="divisor">The divisor.</param>
-    /// <returns>The result of <c>dividend mod divisor</c>.</returns>
-    /// <remarks>
-    ///     The <c>%</c> operator (commonly called the modulo operator) in C# is not defined to be modulo, but is instead
-    ///     remainder. This quirk inherently makes it difficult to use modulo in a negative context, as <c>x % y</c> where x is
-    ///     negative will return a negative value, akin to <c>-(x % y)</c>, even if precedence is forced. This method provides a
-    ///     modulo operation which supports negative dividends.
-    /// </remarks>
-    /// <author>ShreevatsaR, https://stackoverflow.com/a/1082938/1467293</author>
-    /// <license>CC-BY-SA 2.5</license>
-    public static int Mod(this int dividend, int divisor)
-    {
-        int r = dividend % divisor;
-        return r < 0 ? r + divisor : r;
-    }
-
     /// <summary>
     ///     Returns an integer that indicates the sign of this 32-bit signed integer.
     /// </summary>

X10D/src/Int64Extensions/Int64Extensions.cs

@@ -1,7 +1,4 @@
-using System.Diagnostics.Contracts;
+using System.Net;
-using System.Net;
-using System.Runtime.CompilerServices;
-using X10D.Math;
 
 namespace X10D;
 
@@ -10,56 +7,6 @@ namespace X10D;
 /// </summary>
 public static class Int64Extensions
 {
-    /// <summary>
-    ///     Computes the digital root of an integer.
-    /// </summary>
-    /// <param name="value">The value whose digital root to compute.</param>
-    /// <returns>The digital root of <paramref name="value" />.</returns>
-    /// <remarks>The digital root is defined as the recursive sum of digits until that result is a single digit.</remarks>
-    public static long DigitalRoot(this long value)
-    {
-        long root = value.Mod(9);
-        return root < 1 ? 9 - root : root;
-    }
-
-    /// <summary>
-    ///     Converts a Unix time expressed as the number of milliseconds that have elapsed since 1970-01-01T00:00:00Z to a
-    ///     <see cref="DateTimeOffset" /> value.
-    /// </summary>
-    /// <param name="value">
-    ///     A Unix time, expressed as the number of milliseconds that have elapsed since 1970-01-01T00:00:00Z (January 1,
-    ///     1970, at 12:00 AM UTC). For Unix times before this date, its value is negative.
-    /// </param>
-    /// <returns>A date and time value that represents the same moment in time as the Unix time.</returns>
-    /// <exception cref="ArgumentOutOfRangeException">
-    ///     <para><paramref name="value" /> is less than -62,135,596,800,000.</para>
-    ///     -or-
-    ///     <para><paramref name="value" /> is greater than 253,402,300,799,999.</para>
-    /// </exception>
-    public static DateTimeOffset FromUnixTimeMilliseconds(this long value)
-    {
-        return DateTimeOffset.FromUnixTimeMilliseconds(value);
-    }
-
-    /// <summary>
-    ///     Converts a Unix time expressed as the number of seconds that have elapsed since 1970-01-01T00:00:00Z to a
-    ///     <see cref="DateTimeOffset" /> value.
-    /// </summary>
-    /// <param name="value">
-    ///     A Unix time, expressed as the number of seconds that have elapsed since 1970-01-01T00:00:00Z (January 1, 1970, at
-    ///     12:00 AM UTC). For Unix times before this date, its value is negative.
-    /// </param>
-    /// <returns>A date and time value that represents the same moment in time as the Unix time.</returns>
-    /// <exception cref="ArgumentOutOfRangeException">
-    ///     <para><paramref name="value" /> is less than -62,135,596,800.</para>
-    ///     -or-
-    ///     <para><paramref name="value" /> is greater than 253,402,300,799.</para>
-    /// </exception>
-    public static DateTimeOffset FromUnixTimeSeconds(this long value)
-    {
-        return DateTimeOffset.FromUnixTimeSeconds(value);
-    }
-
     /// <summary>
     ///     Returns the current 64-bit signed integer value as an array of bytes.
     /// </summary>
@@ -71,204 +18,49 @@ public static class Int64Extensions
     }
 
     /// <summary>
-    ///     Returns a value indicating whether the current value is evenly divisible by 2.
+    ///     Returns the multiplicative persistence of a specified value.
     /// </summary>
-    /// <param name="value">The value whose parity to check.</param>
+    /// <param name="value">The value whose multiplicative persistence to calculate.</param>
-    /// <returns>
+    /// <returns>The multiplicative persistence.</returns>
-    ///     <see langword="true" /> if <paramref name="value" /> is evenly divisible by 2, or <see langword="false" />
-    ///     otherwise.
-    /// </returns>
-    public static bool IsEven(this long value)
-    {
-        return (value & 1) == 0;
-    }
-
-    /// <summary>
-    ///     Returns a value indicating whether the current value is not evenly divisible by 2.
-    /// </summary>
-    /// <param name="value">The value whose parity to check.</param>
-    /// <returns>
-    ///     <see langword="true" /> if <paramref name="value" /> is not evenly divisible by 2, or <see langword="false" />
-    ///     otherwise.
-    /// </returns>
-    public static bool IsOdd(this long value)
-    {
-        return !value.IsEven();
-    }
-
-    /// <summary>
-    ///     Returns a value indicating whether the current value is a prime number.
-    /// </summary>
-    /// <param name="value">The value whose primality to check.</param>
-    /// <returns>
-    ///     <see langword="true" /> if <paramref name="value" /> is prime; otherwise, <see langword="false" />.
-    /// </returns>
-    public static bool IsPrime(this long value)
-    {
-        switch (value)
-        {
-            case < 2: return false;
-            case 2:
-            case 3: return true;
-        }
-
-        if (value % 2 == 0 || value % 3 == 0)
-        {
-            return false;
-        }
-
-        if ((value + 1) % 6 != 0 && (value - 1) % 6 != 0)
-        {
-            return false;
-        }
-
-        for (var iterator = 5L; iterator * iterator <= value; iterator += 6)
-        {
-            if (value % iterator == 0 || value % (iterator + 2) == 0)
-            {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    /// <summary>
-    ///     Linearly interpolates to the current value from a specified source using a specified alpha.
-    /// </summary>
-    /// <param name="target">The interpolation target.</param>
-    /// <param name="value">The interpolation source.</param>
-    /// <param name="alpha">The interpolation alpha.</param>
-    /// <returns>
-    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
-    /// </returns>
-    public static double LerpFrom(this long target, double value, double alpha)
-    {
-        return MathUtility.Lerp(value, target, alpha);
-    }
-
-    /// <summary>
-    ///     Linearly interpolates to the current value from a specified source using a specified alpha.
-    /// </summary>
-    /// <param name="target">The interpolation target.</param>
-    /// <param name="value">The interpolation source.</param>
-    /// <param name="alpha">The interpolation alpha.</param>
-    /// <returns>
-    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
-    /// </returns>
-    public static float LerpFrom(this long target, float value, float alpha)
-    {
-        return MathUtility.Lerp(value, target, alpha);
-    }
-
-    /// <summary>
-    ///     Linearly interpolates from the current value to a specified target using a specified alpha.
-    /// </summary>
-    /// <param name="value">The interpolation source.</param>
-    /// <param name="target">The interpolation target.</param>
-    /// <param name="alpha">The interpolation alpha.</param>
-    /// <returns>
-    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
-    /// </returns>
-    public static double LerpTo(this long value, double target, double alpha)
-    {
-        return MathUtility.Lerp(value, target, alpha);
-    }
-
-    /// <summary>
-    ///     Linearly interpolates from the current value to a specified target using a specified alpha.
-    /// </summary>
-    /// <param name="value">The interpolation source.</param>
-    /// <param name="target">The interpolation target.</param>
-    /// <param name="alpha">The interpolation alpha.</param>
-    /// <returns>
-    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
-    /// </returns>
-    public static float LerpTo(this long value, float target, float alpha)
-    {
-        return MathUtility.Lerp(value, target, alpha);
-    }
-
-    /// <summary>
-    ///     Linearly interpolates to a specified target from a specified source, using the current value as the alpha value.
-    /// </summary>
-    /// <param name="alpha">The interpolation alpha.</param>
-    /// <param name="value">The interpolation source.</param>
-    /// <param name="target">The interpolation target.</param>
-    /// <returns>
-    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
-    /// </returns>
-    public static double LerpWith(this long alpha, double value, double target)
-    {
-        return MathUtility.Lerp(value, target, alpha);
-    }
-
-    /// <summary>
-    ///     Linearly interpolates to a specified target from a specified source, using the current value as the alpha value.
-    /// </summary>
-    /// <param name="alpha">The interpolation alpha.</param>
-    /// <param name="value">The interpolation source.</param>
-    /// <param name="target">The interpolation target.</param>
-    /// <returns>
-    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
-    /// </returns>
-    public static float LerpWith(this long alpha, float value, float target)
-    {
-        return MathUtility.Lerp(value, target, alpha);
-    }
-
-    /// <summary>
-    ///     Performs a modulo operation which supports a negative dividend.
-    /// </summary>
-    /// <param name="dividend">The dividend.</param>
-    /// <param name="divisor">The divisor.</param>
-    /// <returns>The result of <c>dividend mod divisor</c>.</returns>
     /// <remarks>
-    ///     The <c>%</c> operator (commonly called the modulo operator) in C# is not defined to be modulo, but is instead
+    ///     Multiplicative persistence is defined as the recursive digital product until that product is a single digit.
-    ///     remainder. This quirk inherently makes it difficult to use modulo in a negative context, as <c>x % y</c> where x is
-    ///     negative will return a negative value, akin to <c>-(x % y)</c>, even if precedence is forced. This method provides a
-    ///     modulo operation which supports negative dividends.
     /// </remarks>
-    /// <author>ShreevatsaR, https://stackoverflow.com/a/1082938/1467293</author>
+    public static int MultiplicativePersistence(this long value)
-    /// <license>CC-BY-SA 2.5</license>
-    public static long Mod(this long dividend, long divisor)
     {
-        long r = dividend % divisor;
+        var persistence = 0;
-        return r < 0 ? r + divisor : r;
+        long product = value;
-    }
 
-    /// <summary>
+        const string foo = "Hello" + "World";
-    ///     Returns an integer that indicates the sign of this 64-bit signed integer.
+
-    /// </summary>
+        while (product > 9)
-    /// <param name="value">A signed number.</param>
+        {
-    /// <returns>
+            if (value % 10 == 0)
-    ///     A number that indicates the sign of <paramref name="value" />, as shown in the following table.
+            {
-    ///
+                return persistence + 1;
-    ///     <list type="table">
+            }
-    ///         <listheader>
+
-    ///             <term>Return value</term>
+            while (value > 9)
-    ///             <description>Meaning</description>
+            {
-    ///         </listheader>
+                value /= 10;
-    ///
+                if (value % 10 == 0)
-    ///         <item>
+                {
-    ///             <term>-1</term>
+                    return persistence + 1;
-    ///             <description><paramref name="value" /> is less than zero.</description>
+                }
-    ///         </item>
+            }
-    ///         <item>
+
-    ///             <term>0</term>
+            long newProduct = 1;
-    ///             <description><paramref name="value" /> is equal to zero.</description>
+            long currentProduct = product;
-    ///         </item>
+            while (currentProduct > 0)
-    ///         <item>
+            {
-    ///             <term>1</term>
+                newProduct *= currentProduct % 10;
-    ///             <description><paramref name="value" /> is greater than zero.</description>
+                currentProduct /= 10;
-    ///         </item>
+            }
-    ///     </list>
+
-    /// </returns>
+            product = newProduct;
-    [Pure]
+            persistence++;
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+        }
-    public static int Sign(this long value)
+
-    {
+        return persistence;
-        return System.Math.Sign(value);
     }
 
     /// <summary>

X10D/src/Math/ByteExtensions.cs

@@ -1,10 +1,31 @@
-namespace X10D.Math;
+using System.Diagnostics.Contracts;
+using System.Runtime.CompilerServices;
+
+namespace X10D.Math;
 
 /// <summary>
 ///     Math-related extension methods for <see cref="byte" />.
 /// </summary>
 public static class ByteExtensions
 {
+    /// <summary>
+    ///     Computes the digital root of this 16-bit integer.
+    /// </summary>
+    /// <param name="value">The value whose digital root to compute.</param>
+    /// <returns>The digital root of <paramref name="value" />.</returns>
+    /// <remarks>The digital root is defined as the recursive sum of digits until that result is a single digit.</remarks>
+    /// <remarks>
+    ///     <para>The digital root is defined as the recursive sum of digits until that result is a single digit.</para>
+    ///     <para>For example, the digital root of 239 is 5: <c>2 + 3 + 9 = 14</c>, then <c>1 + 4 = 5</c>.</para>
+    /// </remarks>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static byte DigitalRoot(this byte value)
+    {
+        int root = value % 9;
+        return (byte)(root == 0 ? 9 : root);
+    }
+
     /// <summary>
     ///     Returns the factorial of the current 8-bit unsigned integer.
     /// </summary>

X10D/src/Math/Int16Extensions.cs

@@ -1,16 +1,38 @@
-namespace X10D.Math;
+using System.Diagnostics.Contracts;
+using System.Runtime.CompilerServices;
+
+namespace X10D.Math;
 
 /// <summary>
 ///     Extension methods for <see cref="short" />.
 /// </summary>
 public static class Int16Extensions
 {
+    /// <summary>
+    ///     Computes the digital root of this 16-bit integer.
+    /// </summary>
+    /// <param name="value">The value whose digital root to compute.</param>
+    /// <returns>The digital root of <paramref name="value" />.</returns>
+    /// <remarks>
+    ///     <para>The digital root is defined as the recursive sum of digits until that result is a single digit.</para>
+    ///     <para>For example, the digital root of 239 is 5: <c>2 + 3 + 9 = 14</c>, then <c>1 + 4 = 5</c>.</para>
+    /// </remarks>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static short DigitalRoot(this short value)
+    {
+        short root = System.Math.Abs(value).Mod(9);
+        return root < 1 ? (short)(9 - root) : root;
+    }
+
     /// <summary>
     ///     Returns the factorial of the current 16-bit signed integer.
     /// </summary>
     /// <param name="value">The value whose factorial to compute.</param>
     /// <returns>The factorial of <paramref name="value" />.</returns>
     /// <exception cref="ArithmeticException"><paramref name="value" /> is less than 0.</exception>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
     public static long Factorial(this short value)
     {
         if (value < 0)
@@ -31,4 +53,152 @@ public static class Int16Extensions
 
         return result;
     }
+
+    /// <summary>
+    ///     Returns a value indicating whether the current value is evenly divisible by 2.
+    /// </summary>
+    /// <param name="value">The value whose parity to check.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> is evenly divisible by 2, or <see langword="false" />
+    ///     otherwise.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static bool IsEven(this short value)
+    {
+        return (value & 1) == 0;
+    }
+
+    /// <summary>
+    ///     Returns a value indicating whether the current value is not evenly divisible by 2.
+    /// </summary>
+    /// <param name="value">The value whose parity to check.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> is not evenly divisible by 2, or <see langword="false" />
+    ///     otherwise.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static bool IsOdd(this short value)
+    {
+        return !value.IsEven();
+    }
+
+    /// <summary>
+    ///     Returns a value indicating whether the current value is a prime number.
+    /// </summary>
+    /// <param name="value">The value whose primality to check.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> is prime; otherwise, <see langword="false" />.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static bool IsPrime(this short value)
+    {
+        return ((long)value).IsPrime();
+    }
+
+    /// <summary>
+    ///     Linearly interpolates to the current value from a specified source using a specified alpha.
+    /// </summary>
+    /// <param name="target">The interpolation target.</param>
+    /// <param name="value">The interpolation source.</param>
+    /// <param name="alpha">The interpolation alpha.</param>
+    /// <returns>
+    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static double LerpFrom(this short target, double value, double alpha)
+    {
+        return MathUtility.Lerp(value, target, alpha);
+    }
+
+    /// <summary>
+    ///     Linearly interpolates to the current value from a specified source using a specified alpha.
+    /// </summary>
+    /// <param name="target">The interpolation target.</param>
+    /// <param name="value">The interpolation source.</param>
+    /// <param name="alpha">The interpolation alpha.</param>
+    /// <returns>
+    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static float LerpFrom(this short target, float value, float alpha)
+    {
+        return MathUtility.Lerp(value, target, alpha);
+    }
+
+    /// <summary>
+    ///     Linearly interpolates from the current value to a specified target using a specified alpha.
+    /// </summary>
+    /// <param name="value">The interpolation source.</param>
+    /// <param name="target">The interpolation target.</param>
+    /// <param name="alpha">The interpolation alpha.</param>
+    /// <returns>
+    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static double LerpTo(this short value, double target, double alpha)
+    {
+        return MathUtility.Lerp(value, target, alpha);
+    }
+
+    /// <summary>
+    ///     Performs a modulo operation which supports a negative dividend.
+    /// </summary>
+    /// <param name="dividend">The dividend.</param>
+    /// <param name="divisor">The divisor.</param>
+    /// <returns>The result of <c>dividend mod divisor</c>.</returns>
+    /// <remarks>
+    ///     The <c>%</c> operator (commonly called the modulo operator) in C# is not defined to be modulo, but is instead
+    ///     remainder. This quirk inherently makes it difficult to use modulo in a negative context, as <c>x % y</c> where x is
+    ///     negative will return a negative value, akin to <c>-(x % y)</c>, even if precedence is forced. This method provides a
+    ///     modulo operation which supports negative dividends.
+    /// </remarks>
+    /// <author>ShreevatsaR, https://stackoverflow.com/a/1082938/1467293</author>
+    /// <license>CC-BY-SA 2.5</license>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static short Mod(this short dividend, short divisor)
+    {
+        int r = dividend % divisor;
+        return (short)(r < 0 ? r + divisor : r);
+    }
+
+    /// <summary>
+    ///     Returns an integer that indicates the sign of this 16-bit signed integer.
+    /// </summary>
+    /// <param name="value">A signed number.</param>
+    /// <returns>
+    ///     A number that indicates the sign of <paramref name="value" />, as shown in the following table.
+    ///
+    ///     <list type="table">
+    ///         <listheader>
+    ///             <term>Return value</term>
+    ///             <description>Meaning</description>
+    ///         </listheader>
+    ///
+    ///         <item>
+    ///             <term>-1</term>
+    ///             <description><paramref name="value" /> is less than zero.</description>
+    ///         </item>
+    ///         <item>
+    ///             <term>0</term>
+    ///             <description><paramref name="value" /> is equal to zero.</description>
+    ///         </item>
+    ///         <item>
+    ///             <term>1</term>
+    ///             <description><paramref name="value" /> is greater than zero.</description>
+    ///         </item>
+    ///     </list>
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static int Sign(this short value)
+    {
+        return System.Math.Sign(value);
+    }
 }

X10D/src/Math/Int32Extensions.cs

@@ -1,16 +1,38 @@
-namespace X10D.Math;
+using System.Diagnostics.Contracts;
+using System.Runtime.CompilerServices;
+
+namespace X10D.Math;
 
 /// <summary>
 ///     Extension methods for <see cref="int" />.
 /// </summary>
 public static class Int32Extensions
 {
+    /// <summary>
+    ///     Computes the digital root of this 32-bit integer.
+    /// </summary>
+    /// <param name="value">The value whose digital root to compute.</param>
+    /// <returns>The digital root of <paramref name="value" />.</returns>
+    /// <remarks>
+    ///     <para>The digital root is defined as the recursive sum of digits until that result is a single digit.</para>
+    ///     <para>For example, the digital root of 239 is 5: <c>2 + 3 + 9 = 14</c>, then <c>1 + 4 = 5</c>.</para>
+    /// </remarks>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static int DigitalRoot(this int value)
+    {
+        int root = System.Math.Abs(value).Mod(9);
+        return root < 1 ? 9 - root : root;
+    }
+
     /// <summary>
     ///     Returns the factorial of the current 32-bit signed integer.
     /// </summary>
     /// <param name="value">The value whose factorial to compute.</param>
     /// <returns>The factorial of <paramref name="value" />.</returns>
     /// <exception cref="ArithmeticException"><paramref name="value" /> is less than 0.</exception>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
     public static long Factorial(this int value)
     {
         if (value < 0)
@@ -31,4 +53,166 @@ public static class Int32Extensions
 
         return result;
     }
+
+    /// <summary>
+    ///     Returns a value indicating whether the current value is evenly divisible by 2.
+    /// </summary>
+    /// <param name="value">The value whose parity to check.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> is evenly divisible by 2, or <see langword="false" />
+    ///     otherwise.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static bool IsEven(this int value)
+    {
+        return (value & 1) == 0;
+    }
+
+    /// <summary>
+    ///     Returns a value indicating whether the current value is not evenly divisible by 2.
+    /// </summary>
+    /// <param name="value">The value whose parity to check.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> is not evenly divisible by 2, or <see langword="false" />
+    ///     otherwise.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static bool IsOdd(this int value)
+    {
+        return !value.IsEven();
+    }
+
+    /// <summary>
+    ///     Returns a value indicating whether the current value is a prime number.
+    /// </summary>
+    /// <param name="value">The value whose primality to check.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> is prime; otherwise, <see langword="false" />.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static bool IsPrime(this int value)
+    {
+        return ((long)value).IsPrime();
+    }
+
+    /// <summary>
+    ///     Linearly interpolates to the current value from a specified source using a specified alpha.
+    /// </summary>
+    /// <param name="target">The interpolation target.</param>
+    /// <param name="value">The interpolation source.</param>
+    /// <param name="alpha">The interpolation alpha.</param>
+    /// <returns>
+    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static double LerpFrom(this int target, double value, double alpha)
+    {
+        return MathUtility.Lerp(value, target, alpha);
+    }
+
+    /// <summary>
+    ///     Linearly interpolates to the current value from a specified source using a specified alpha.
+    /// </summary>
+    /// <param name="target">The interpolation target.</param>
+    /// <param name="value">The interpolation source.</param>
+    /// <param name="alpha">The interpolation alpha.</param>
+    /// <returns>
+    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static float LerpFrom(this int target, float value, float alpha)
+    {
+        return MathUtility.Lerp(value, target, alpha);
+    }
+
+    /// <summary>
+    ///     Linearly interpolates from the current value to a specified target using a specified alpha.
+    /// </summary>
+    /// <param name="value">The interpolation source.</param>
+    /// <param name="target">The interpolation target.</param>
+    /// <param name="alpha">The interpolation alpha.</param>
+    /// <returns>
+    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static double LerpTo(this int value, double target, double alpha)
+    {
+        return MathUtility.Lerp(value, target, alpha);
+    }
+
+    /// <summary>
+    ///     Linearly interpolates from the current value to a specified target using a specified alpha.
+    /// </summary>
+    /// <param name="value">The interpolation source.</param>
+    /// <param name="target">The interpolation target.</param>
+    /// <param name="alpha">The interpolation alpha.</param>
+    /// <returns>
+    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static float LerpTo(this int value, float target, float alpha)
+    {
+        return MathUtility.Lerp(value, target, alpha);
+    }
+
+    /// <summary>
+    ///     Linearly interpolates to a specified target from a specified source, using the current value as the alpha value.
+    /// </summary>
+    /// <param name="alpha">The interpolation alpha.</param>
+    /// <param name="value">The interpolation source.</param>
+    /// <param name="target">The interpolation target.</param>
+    /// <returns>
+    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static double LerpWith(this int alpha, double value, double target)
+    {
+        return MathUtility.Lerp(value, target, alpha);
+    }
+
+    /// <summary>
+    ///     Linearly interpolates to a specified target from a specified source, using the current value as the alpha value.
+    /// </summary>
+    /// <param name="alpha">The interpolation alpha.</param>
+    /// <param name="value">The interpolation source.</param>
+    /// <param name="target">The interpolation target.</param>
+    /// <returns>
+    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static float LerpWith(this int alpha, float value, float target)
+    {
+        return MathUtility.Lerp(value, target, alpha);
+    }
+
+    /// <summary>
+    ///     Performs a modulo operation which supports a negative dividend.
+    /// </summary>
+    /// <param name="dividend">The dividend.</param>
+    /// <param name="divisor">The divisor.</param>
+    /// <returns>The result of <c>dividend mod divisor</c>.</returns>
+    /// <remarks>
+    ///     The <c>%</c> operator (commonly called the modulo operator) in C# is not defined to be modulo, but is instead
+    ///     remainder. This quirk inherently makes it difficult to use modulo in a negative context, as <c>x % y</c> where x is
+    ///     negative will return a negative value, akin to <c>-(x % y)</c>, even if precedence is forced. This method provides a
+    ///     modulo operation which supports negative dividends.
+    /// </remarks>
+    /// <author>ShreevatsaR, https://stackoverflow.com/a/1082938/1467293</author>
+    /// <license>CC-BY-SA 2.5</license>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static int Mod(this int dividend, int divisor)
+    {
+        int r = dividend % divisor;
+        return r < 0 ? r + divisor : r;
+    }
 }

X10D/src/Math/Int64Extensions.cs

@@ -1,16 +1,38 @@
-namespace X10D.Math;
+using System.Diagnostics.Contracts;
+using System.Runtime.CompilerServices;
+
+namespace X10D.Math;
 
 /// <summary>
 ///     Extension methods for <see cref="long" />.
 /// </summary>
 public static class Int64Extensions
 {
+    /// <summary>
+    ///     Computes the digital root of this 64-bit integer.
+    /// </summary>
+    /// <param name="value">The value whose digital root to compute.</param>
+    /// <returns>The digital root of <paramref name="value" />.</returns>
+    /// <remarks>
+    ///     <para>The digital root is defined as the recursive sum of digits until that result is a single digit.</para>
+    ///     <para>For example, the digital root of 239 is 5: <c>2 + 3 + 9 = 14</c>, then <c>1 + 4 = 5</c>.</para>
+    /// </remarks>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static long DigitalRoot(this long value)
+    {
+        long root = System.Math.Abs(value).Mod(9L);
+        return root < 1L ? 9L - root : root;
+    }
+
     /// <summary>
     ///     Returns the factorial of the current 64-bit signed integer.
     /// </summary>
     /// <param name="value">The value whose factorial to compute.</param>
     /// <returns>The factorial of <paramref name="value" />.</returns>
     /// <exception cref="ArithmeticException"><paramref name="value" /> is less than 0.</exception>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
     public static long Factorial(this long value)
     {
         if (value < 0)
@@ -31,4 +53,225 @@ public static class Int64Extensions
 
         return result;
     }
+
+    /// <summary>
+    ///     Returns a value indicating whether the current value is evenly divisible by 2.
+    /// </summary>
+    /// <param name="value">The value whose parity to check.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> is evenly divisible by 2, or <see langword="false" />
+    ///     otherwise.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static bool IsEven(this long value)
+    {
+        return (value & 1) == 0;
+    }
+
+    /// <summary>
+    ///     Returns a value indicating whether the current value is not evenly divisible by 2.
+    /// </summary>
+    /// <param name="value">The value whose parity to check.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> is not evenly divisible by 2, or <see langword="false" />
+    ///     otherwise.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static bool IsOdd(this long value)
+    {
+        return !value.IsEven();
+    }
+
+    /// <summary>
+    ///     Returns a value indicating whether the current value is a prime number.
+    /// </summary>
+    /// <param name="value">The value whose primality to check.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> is prime; otherwise, <see langword="false" />.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static bool IsPrime(this long value)
+    {
+        switch (value)
+        {
+            case < 2: return false;
+            case 2:
+            case 3: return true;
+        }
+
+        if (value % 2 == 0 || value % 3 == 0)
+        {
+            return false;
+        }
+
+        if ((value + 1) % 6 != 0 && (value - 1) % 6 != 0)
+        {
+            return false;
+        }
+
+        for (var iterator = 5L; iterator * iterator <= value; iterator += 6)
+        {
+            if (value % iterator == 0 || value % (iterator + 2) == 0)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    ///     Linearly interpolates to the current value from a specified source using a specified alpha.
+    /// </summary>
+    /// <param name="target">The interpolation target.</param>
+    /// <param name="value">The interpolation source.</param>
+    /// <param name="alpha">The interpolation alpha.</param>
+    /// <returns>
+    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static double LerpFrom(this long target, double value, double alpha)
+    {
+        return MathUtility.Lerp(value, target, alpha);
+    }
+
+    /// <summary>
+    ///     Linearly interpolates to the current value from a specified source using a specified alpha.
+    /// </summary>
+    /// <param name="target">The interpolation target.</param>
+    /// <param name="value">The interpolation source.</param>
+    /// <param name="alpha">The interpolation alpha.</param>
+    /// <returns>
+    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static float LerpFrom(this long target, float value, float alpha)
+    {
+        return MathUtility.Lerp(value, target, alpha);
+    }
+
+    /// <summary>
+    ///     Linearly interpolates from the current value to a specified target using a specified alpha.
+    /// </summary>
+    /// <param name="value">The interpolation source.</param>
+    /// <param name="target">The interpolation target.</param>
+    /// <param name="alpha">The interpolation alpha.</param>
+    /// <returns>
+    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static double LerpTo(this long value, double target, double alpha)
+    {
+        return MathUtility.Lerp(value, target, alpha);
+    }
+
+    /// <summary>
+    ///     Linearly interpolates from the current value to a specified target using a specified alpha.
+    /// </summary>
+    /// <param name="value">The interpolation source.</param>
+    /// <param name="target">The interpolation target.</param>
+    /// <param name="alpha">The interpolation alpha.</param>
+    /// <returns>
+    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static float LerpTo(this long value, float target, float alpha)
+    {
+        return MathUtility.Lerp(value, target, alpha);
+    }
+
+    /// <summary>
+    ///     Linearly interpolates to a specified target from a specified source, using the current value as the alpha value.
+    /// </summary>
+    /// <param name="alpha">The interpolation alpha.</param>
+    /// <param name="value">The interpolation source.</param>
+    /// <param name="target">The interpolation target.</param>
+    /// <returns>
+    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static double LerpWith(this long alpha, double value, double target)
+    {
+        return MathUtility.Lerp(value, target, alpha);
+    }
+
+    /// <summary>
+    ///     Linearly interpolates to a specified target from a specified source, using the current value as the alpha value.
+    /// </summary>
+    /// <param name="alpha">The interpolation alpha.</param>
+    /// <param name="value">The interpolation source.</param>
+    /// <param name="target">The interpolation target.</param>
+    /// <returns>
+    ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static float LerpWith(this long alpha, float value, float target)
+    {
+        return MathUtility.Lerp(value, target, alpha);
+    }
+
+    /// <summary>
+    ///     Performs a modulo operation which supports a negative dividend.
+    /// </summary>
+    /// <param name="dividend">The dividend.</param>
+    /// <param name="divisor">The divisor.</param>
+    /// <returns>The result of <c>dividend mod divisor</c>.</returns>
+    /// <remarks>
+    ///     The <c>%</c> operator (commonly called the modulo operator) in C# is not defined to be modulo, but is instead
+    ///     remainder. This quirk inherently makes it difficult to use modulo in a negative context, as <c>x % y</c> where x is
+    ///     negative will return a negative value, akin to <c>-(x % y)</c>, even if precedence is forced. This method provides a
+    ///     modulo operation which supports negative dividends.
+    /// </remarks>
+    /// <author>ShreevatsaR, https://stackoverflow.com/a/1082938/1467293</author>
+    /// <license>CC-BY-SA 2.5</license>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static long Mod(this long dividend, long divisor)
+    {
+        long r = dividend % divisor;
+        return r < 0 ? r + divisor : r;
+    }
+
+    /// <summary>
+    ///     Returns an integer that indicates the sign of this 64-bit signed integer.
+    /// </summary>
+    /// <param name="value">A signed number.</param>
+    /// <returns>
+    ///     A number that indicates the sign of <paramref name="value" />, as shown in the following table.
+    ///
+    ///     <list type="table">
+    ///         <listheader>
+    ///             <term>Return value</term>
+    ///             <description>Meaning</description>
+    ///         </listheader>
+    ///
+    ///         <item>
+    ///             <term>-1</term>
+    ///             <description><paramref name="value" /> is less than zero.</description>
+    ///         </item>
+    ///         <item>
+    ///             <term>0</term>
+    ///             <description><paramref name="value" /> is equal to zero.</description>
+    ///         </item>
+    ///         <item>
+    ///             <term>1</term>
+    ///             <description><paramref name="value" /> is greater than zero.</description>
+    ///         </item>
+    ///     </list>
+    /// </returns>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static int Sign(this long value)
+    {
+        return System.Math.Sign(value);
+    }
 }

X10D/src/Math/SByteExtensions.cs

@@ -9,6 +9,23 @@ namespace X10D.Math;
 [CLSCompliant(false)]
 public static class SByteExtensions
 {
+    /// <summary>
+    ///     Computes the digital root of this 32-bit integer.
+    /// </summary>
+    /// <param name="value">The value whose digital root to compute.</param>
+    /// <returns>The digital root of <paramref name="value" />.</returns>
+    /// <remarks>
+    ///     <para>The digital root is defined as the recursive sum of digits until that result is a single digit.</para>
+    ///     <para>For example, the digital root of 239 is 5: <c>2 + 3 + 9 = 14</c>, then <c>1 + 4 = 5</c>.</para>
+    /// </remarks>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static sbyte DigitalRoot(this sbyte value)
+    {
+        int root = System.Math.Abs(value).Mod(9);
+        return (sbyte)(root < 1 ? 9 - root : root);
+    }
+
     /// <summary>
     ///     Returns the factorial of the current 8-bit signed integer.
     /// </summary>
@@ -82,6 +99,28 @@ public static class SByteExtensions
         return ((long)value).IsPrime();
     }
 
+    /// <summary>
+    ///     Performs a modulo operation which supports a negative dividend.
+    /// </summary>
+    /// <param name="dividend">The dividend.</param>
+    /// <param name="divisor">The divisor.</param>
+    /// <returns>The result of <c>dividend mod divisor</c>.</returns>
+    /// <remarks>
+    ///     The <c>%</c> operator (commonly called the modulo operator) in C# is not defined to be modulo, but is instead
+    ///     remainder. This quirk inherently makes it difficult to use modulo in a negative context, as <c>x % y</c> where x is
+    ///     negative will return a negative value, akin to <c>-(x % y)</c>, even if precedence is forced. This method provides a
+    ///     modulo operation which supports negative dividends.
+    /// </remarks>
+    /// <author>ShreevatsaR, https://stackoverflow.com/a/1082938/1467293</author>
+    /// <license>CC-BY-SA 2.5</license>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static sbyte Mod(this sbyte dividend, sbyte divisor)
+    {
+        int r = dividend % divisor;
+        return (sbyte)(r < 0 ? r + divisor : r);
+    }
+
     /// <summary>
     ///     Returns an integer that indicates the sign of this 8-bit signed integer.
     /// </summary>

X10D/src/Math/UInt16Extensions.cs

@@ -1,4 +1,7 @@
-namespace X10D.Math;
+using System.Diagnostics.Contracts;
+using System.Runtime.CompilerServices;
+
+namespace X10D.Math;
 
 /// <summary>
 ///     Extension methods for <see cref="ushort" />.
@@ -6,6 +9,23 @@
 [CLSCompliant(false)]
 public static class UInt16Extensions
 {
+    /// <summary>
+    ///     Computes the digital root of the current 16-bit unsigned integer.
+    /// </summary>
+    /// <param name="value">The value whose digital root to compute.</param>
+    /// <returns>The digital root of <paramref name="value" />.</returns>
+    /// <remarks>
+    ///     <para>The digital root is defined as the recursive sum of digits until that result is a single digit.</para>
+    ///     <para>For example, the digital root of 239 is 5: <c>2 + 3 + 9 = 14</c>, then <c>1 + 4 = 5</c>.</para>
+    /// </remarks>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static ushort DigitalRoot(this ushort value)
+    {
+        var root = (ushort)(value % 9);
+        return (ushort)(root == 0 ? 9 : root);
+    }
+
     /// <summary>
     ///     Returns the factorial of the current 16-bit unsigned integer.
     /// </summary>

X10D/src/Math/UInt32Extensions.cs

@@ -1,4 +1,7 @@
-namespace X10D.Math;
+using System.Diagnostics.Contracts;
+using System.Runtime.CompilerServices;
+
+namespace X10D.Math;
 
 /// <summary>
 ///     Extension methods for <see cref="uint" />.
@@ -6,6 +9,23 @@
 [CLSCompliant(false)]
 public static class UInt32Extensions
 {
+    /// <summary>
+    ///     Computes the digital root of the current 32-bit unsigned integer.
+    /// </summary>
+    /// <param name="value">The value whose digital root to compute.</param>
+    /// <returns>The digital root of <paramref name="value" />.</returns>
+    /// <remarks>
+    ///     <para>The digital root is defined as the recursive sum of digits until that result is a single digit.</para>
+    ///     <para>For example, the digital root of 239 is 5: <c>2 + 3 + 9 = 14</c>, then <c>1 + 4 = 5</c>.</para>
+    /// </remarks>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static uint DigitalRoot(this uint value)
+    {
+        uint root = value % 9;
+        return root == 0 ? 9 : root;
+    }
+
     /// <summary>
     ///     Returns the factorial of the current 32-bit unsigned integer.
     /// </summary>

X10D/src/Math/UInt64Extensions.cs

@@ -1,4 +1,7 @@
-namespace X10D.Math;
+using System.Diagnostics.Contracts;
+using System.Runtime.CompilerServices;
+
+namespace X10D.Math;
 
 /// <summary>
 ///     Extension methods for <see cref="ulong" />.
@@ -6,6 +9,23 @@
 [CLSCompliant(false)]
 public static class UInt64Extensions
 {
+    /// <summary>
+    ///     Computes the digital root of the current 64-bit unsigned integer.
+    /// </summary>
+    /// <param name="value">The value whose digital root to compute.</param>
+    /// <returns>The digital root of <paramref name="value" />.</returns>
+    /// <remarks>
+    ///     <para>The digital root is defined as the recursive sum of digits until that result is a single digit.</para>
+    ///     <para>For example, the digital root of 239 is 5: <c>2 + 3 + 9 = 14</c>, then <c>1 + 4 = 5</c>.</para>
+    /// </remarks>
+    [Pure]
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static ulong DigitalRoot(this ulong value)
+    {
+        ulong root = value % 9;
+        return root == 0 ? 9 : root;
+    }
+
     /// <summary>
     ///     Returns the factorial of the current 64-bit unsigned integer.
     /// </summary>

X10D/src/Time/Int16Extensions.cs

@@ -5,6 +5,44 @@
 /// </summary>
 public static class Int16Extensions
 {
+    /// <summary>
+    ///     Converts a Unix time expressed as the number of milliseconds that have elapsed since 1970-01-01T00:00:00Z to a
+    ///     <see cref="DateTimeOffset" /> value.
+    /// </summary>
+    /// <param name="value">
+    ///     A Unix time, expressed as the number of milliseconds that have elapsed since 1970-01-01T00:00:00Z (January 1, 1970, at
+    ///     12:00 AM UTC). For Unix times before this date, its value is negative.
+    /// </param>
+    /// <returns>A date and time value that represents the same moment in time as the Unix time.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">
+    ///     <para><paramref name="value" /> is less than -62,135,596,800,000.</para>
+    ///     -or-
+    ///     <para><paramref name="value" /> is greater than 253,402,300,799,999.</para>
+    /// </exception>
+    public static DateTimeOffset FromUnixTimeMilliseconds(this short value)
+    {
+        return DateTimeOffset.FromUnixTimeMilliseconds(value);
+    }
+
+    /// <summary>
+    ///     Converts a Unix time expressed as the number of seconds that have elapsed since 1970-01-01T00:00:00Z to a
+    ///     <see cref="DateTimeOffset" /> value.
+    /// </summary>
+    /// <param name="value">
+    ///     A Unix time, expressed as the number of seconds that have elapsed since 1970-01-01T00:00:00Z (January 1, 1970, at
+    ///     12:00 AM UTC). For Unix times before this date, its value is negative.
+    /// </param>
+    /// <returns>A date and time value that represents the same moment in time as the Unix time.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">
+    ///     <para><paramref name="value" /> is less than -62,135,596,800.</para>
+    ///     -or-
+    ///     <para><paramref name="value" /> is greater than 253,402,300,799.</para>
+    /// </exception>
+    public static DateTimeOffset FromUnixTimeSeconds(this short value)
+    {
+        return DateTimeOffset.FromUnixTimeSeconds(value);
+    }
+
     /// <summary>
     ///     Returns a <see cref="TimeSpan" /> that represents this value as the number of ticks.
     /// </summary>

X10D/src/Time/Int32Extensions.cs

@@ -5,6 +5,44 @@
 /// </summary>
 public static class Int32Extensions
 {
+    /// <summary>
+    ///     Converts a Unix time expressed as the number of milliseconds that have elapsed since 1970-01-01T00:00:00Z to a
+    ///     <see cref="DateTimeOffset" /> value.
+    /// </summary>
+    /// <param name="value">
+    ///     A Unix time, expressed as the number of milliseconds that have elapsed since 1970-01-01T00:00:00Z (January 1,
+    ///     1970, at 12:00 AM UTC). For Unix times before this date, its value is negative.
+    /// </param>
+    /// <returns>A date and time value that represents the same moment in time as the Unix time.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">
+    ///     <para><paramref name="value" /> is less than -62,135,596,800,000.</para>
+    ///     -or-
+    ///     <para><paramref name="value" /> is greater than 253,402,300,799,999.</para>
+    /// </exception>
+    public static DateTimeOffset FromUnixTimeMilliseconds(this int value)
+    {
+        return DateTimeOffset.FromUnixTimeMilliseconds(value);
+    }
+
+    /// <summary>
+    ///     Converts a Unix time expressed as the number of seconds that have elapsed since 1970-01-01T00:00:00Z to a
+    ///     <see cref="DateTimeOffset" /> value.
+    /// </summary>
+    /// <param name="value">
+    ///     A Unix time, expressed as the number of seconds that have elapsed since 1970-01-01T00:00:00Z (January 1, 1970, at
+    ///     12:00 AM UTC). For Unix times before this date, its value is negative.
+    /// </param>
+    /// <returns>A date and time value that represents the same moment in time as the Unix time.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">
+    ///     <para><paramref name="value" /> is less than -62,135,596,800.</para>
+    ///     -or-
+    ///     <para><paramref name="value" /> is greater than 253,402,300,799.</para>
+    /// </exception>
+    public static DateTimeOffset FromUnixTimeSeconds(this int value)
+    {
+        return DateTimeOffset.FromUnixTimeSeconds(value);
+    }
+
     /// <summary>
     ///     Returns a <see cref="TimeSpan" /> that represents this value as the number of ticks.
     /// </summary>

X10D/src/Time/Int64Extensions.cs

@@ -5,6 +5,44 @@
 /// </summary>
 public static class Int64Extensions
 {
+    /// <summary>
+    ///     Converts a Unix time expressed as the number of milliseconds that have elapsed since 1970-01-01T00:00:00Z to a
+    ///     <see cref="DateTimeOffset" /> value.
+    /// </summary>
+    /// <param name="value">
+    ///     A Unix time, expressed as the number of milliseconds that have elapsed since 1970-01-01T00:00:00Z (January 1,
+    ///     1970, at 12:00 AM UTC). For Unix times before this date, its value is negative.
+    /// </param>
+    /// <returns>A date and time value that represents the same moment in time as the Unix time.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">
+    ///     <para><paramref name="value" /> is less than -62,135,596,800,000.</para>
+    ///     -or-
+    ///     <para><paramref name="value" /> is greater than 253,402,300,799,999.</para>
+    /// </exception>
+    public static DateTimeOffset FromUnixTimeMilliseconds(this long value)
+    {
+        return DateTimeOffset.FromUnixTimeMilliseconds(value);
+    }
+
+    /// <summary>
+    ///     Converts a Unix time expressed as the number of seconds that have elapsed since 1970-01-01T00:00:00Z to a
+    ///     <see cref="DateTimeOffset" /> value.
+    /// </summary>
+    /// <param name="value">
+    ///     A Unix time, expressed as the number of seconds that have elapsed since 1970-01-01T00:00:00Z (January 1, 1970, at
+    ///     12:00 AM UTC). For Unix times before this date, its value is negative.
+    /// </param>
+    /// <returns>A date and time value that represents the same moment in time as the Unix time.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">
+    ///     <para><paramref name="value" /> is less than -62,135,596,800.</para>
+    ///     -or-
+    ///     <para><paramref name="value" /> is greater than 253,402,300,799.</para>
+    /// </exception>
+    public static DateTimeOffset FromUnixTimeSeconds(this long value)
+    {
+        return DateTimeOffset.FromUnixTimeSeconds(value);
+    }
+
     /// <summary>
     ///     Returns a <see cref="TimeSpan" /> that represents this value as the number of ticks.
     /// </summary>