diff --git a/CHANGELOG.md b/CHANGELOG.md
index a0fcace..e7daff2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - X10D: Added extension methods for `DateOnly`, for parity with `DateTime` and `DateTimeOffset`.
 - X10D: Added math-related extension methods for `BigInteger`.
 - X10D: Added `Span<T>.Replace(T, T)`.
+- X10D: Added `CountDigits` for integer types.
 
 ### Changed
 - X10D: `DateTime.Age(DateTime)` and `DateTimeOffset.Age(DateTimeOffset)` parameter renamed from `asOf` to `referenceDate`.
diff --git a/X10D.Tests/src/Math/BigIntegerTests.cs b/X10D.Tests/src/Math/BigIntegerTests.cs
index bbe3b09..2151798 100644
--- a/X10D.Tests/src/Math/BigIntegerTests.cs
+++ b/X10D.Tests/src/Math/BigIntegerTests.cs
@@ -7,6 +7,61 @@ namespace X10D.Tests.Math;
 [TestFixture]
 public partial class BigIntegerTests
 {
+    [Test]
+    public void CountDigits_ShouldReturn1_Given0()
+    {
+        BigInteger value = 0;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn1_Given1()
+    {
+        BigInteger value = 1;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn1_GivenNegative1()
+    {
+        BigInteger value = -1;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn2_Given10()
+    {
+        BigInteger value = 10;
+        const int expected = 2;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn3_Given199()
+    {
+        BigInteger value = 199;
+        const int expected = 3;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
     [Test]
     public void DigitalRootShouldBeCorrect()
     {
diff --git a/X10D.Tests/src/Math/ByteTests.cs b/X10D.Tests/src/Math/ByteTests.cs
index e139eb1..3419f3e 100644
--- a/X10D.Tests/src/Math/ByteTests.cs
+++ b/X10D.Tests/src/Math/ByteTests.cs
@@ -6,6 +6,50 @@ namespace X10D.Tests.Math;
 [TestFixture]
 public partial class ByteTests
 {
+    [Test]
+    public void CountDigits_ShouldReturn1_Given0()
+    {
+        const byte value = 0;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn1_Given1()
+    {
+        const byte value = 1;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn2_Given10()
+    {
+        const byte value = 10;
+        const int expected = 2;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn3_Given199()
+    {
+        const byte value = 199;
+        const int expected = 3;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
     [Test]
     public void DigitalRootShouldBeCorrect()
     {
diff --git a/X10D.Tests/src/Math/Int16Tests.cs b/X10D.Tests/src/Math/Int16Tests.cs
index 50591cc..3823264 100644
--- a/X10D.Tests/src/Math/Int16Tests.cs
+++ b/X10D.Tests/src/Math/Int16Tests.cs
@@ -6,6 +6,61 @@ namespace X10D.Tests.Math;
 [TestFixture]
 public partial class Int16Tests
 {
+    [Test]
+    public void CountDigits_ShouldReturn1_Given0()
+    {
+        const short value = 0;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn1_Given1()
+    {
+        const short value = 1;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn1_GivenNegative1()
+    {
+        const short value = -1;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn2_Given10()
+    {
+        const short value = 10;
+        const int expected = 2;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn3_Given199()
+    {
+        const short value = 199;
+        const int expected = 3;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
     [Test]
     public void DigitalRootShouldBeCorrect()
     {
diff --git a/X10D.Tests/src/Math/Int32Tests.cs b/X10D.Tests/src/Math/Int32Tests.cs
index e412200..7711d3d 100644
--- a/X10D.Tests/src/Math/Int32Tests.cs
+++ b/X10D.Tests/src/Math/Int32Tests.cs
@@ -6,6 +6,61 @@ namespace X10D.Tests.Math;
 [TestFixture]
 public partial class Int32Tests
 {
+    [Test]
+    public void CountDigits_ShouldReturn1_Given0()
+    {
+        const int value = 0;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn1_Given1()
+    {
+        const int value = 1;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn1_GivenNegative1()
+    {
+        const int value = -1;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn2_Given10()
+    {
+        const int value = 10;
+        const int expected = 2;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn3_Given199()
+    {
+        const int value = 199;
+        const int expected = 3;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
     [Test]
     public void DigitalRootShouldBeCorrect()
     {
diff --git a/X10D.Tests/src/Math/Int64Tests.cs b/X10D.Tests/src/Math/Int64Tests.cs
index de56cd9..557e0b0 100644
--- a/X10D.Tests/src/Math/Int64Tests.cs
+++ b/X10D.Tests/src/Math/Int64Tests.cs
@@ -6,6 +6,61 @@ namespace X10D.Tests.Math;
 [TestFixture]
 public partial class Int64Tests
 {
+    [Test]
+    public void CountDigits_ShouldReturn1_Given0()
+    {
+        const long value = 0;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn1_Given1()
+    {
+        const long value = 1;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn1_GivenNegative1()
+    {
+        const long value = -1;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn2_Given10()
+    {
+        const long value = 10;
+        const int expected = 2;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn3_Given199()
+    {
+        const long value = 199;
+        const int expected = 3;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
     [Test]
     public void DigitalRootShouldBeCorrect()
     {
diff --git a/X10D.Tests/src/Math/SByteTests.cs b/X10D.Tests/src/Math/SByteTests.cs
index 703b1af..454e35f 100644
--- a/X10D.Tests/src/Math/SByteTests.cs
+++ b/X10D.Tests/src/Math/SByteTests.cs
@@ -7,6 +7,61 @@ namespace X10D.Tests.Math;
 [CLSCompliant(false)]
 public partial class SByteTests
 {
+    [Test]
+    public void CountDigits_ShouldReturn1_Given0()
+    {
+        const sbyte value = 0;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn1_Given1()
+    {
+        const sbyte value = 1;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn1_GivenNegative1()
+    {
+        const sbyte value = -1;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn2_Given10()
+    {
+        const sbyte value = 10;
+        const int expected = 2;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn3_Given127()
+    {
+        const sbyte value = 127;
+        const int expected = 3;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
     [Test]
     public void DigitalRootShouldBeCorrect()
     {
diff --git a/X10D.Tests/src/Math/UInt16Tests.cs b/X10D.Tests/src/Math/UInt16Tests.cs
index 7055a00..f123de7 100644
--- a/X10D.Tests/src/Math/UInt16Tests.cs
+++ b/X10D.Tests/src/Math/UInt16Tests.cs
@@ -7,6 +7,50 @@ namespace X10D.Tests.Math;
 [CLSCompliant(false)]
 public partial class UInt16Tests
 {
+    [Test]
+    public void CountDigits_ShouldReturn1_Given0()
+    {
+        const ushort value = 0;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn1_Given1()
+    {
+        const ushort value = 1;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn2_Given10()
+    {
+        const ushort value = 10;
+        const int expected = 2;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn3_Given199()
+    {
+        const ushort value = 199;
+        const int expected = 3;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
     [Test]
     public void DigitalRootShouldBeCorrect()
     {
diff --git a/X10D.Tests/src/Math/UInt32Tests.cs b/X10D.Tests/src/Math/UInt32Tests.cs
index b550667..a6c2911 100644
--- a/X10D.Tests/src/Math/UInt32Tests.cs
+++ b/X10D.Tests/src/Math/UInt32Tests.cs
@@ -7,6 +7,49 @@ namespace X10D.Tests.Math;
 [CLSCompliant(false)]
 public partial class UInt32Tests
 {
+    [Test]
+    public void CountDigits_ShouldReturn1_Given0()
+    {
+        const uint value = 0;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn1_Given1()
+    {
+        const uint value = 1;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+    [Test]
+    public void CountDigits_ShouldReturn2_Given10()
+    {
+        const uint value = 10;
+        const int expected = 2;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn3_Given199()
+    {
+        const uint value = 199;
+        const int expected = 3;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
     [Test]
     public void DigitalRootShouldBeCorrect()
     {
diff --git a/X10D.Tests/src/Math/UInt64Tests.cs b/X10D.Tests/src/Math/UInt64Tests.cs
index 777c5ab..6d05b4d 100644
--- a/X10D.Tests/src/Math/UInt64Tests.cs
+++ b/X10D.Tests/src/Math/UInt64Tests.cs
@@ -7,6 +7,50 @@ namespace X10D.Tests.Math;
 [CLSCompliant(false)]
 public partial class UInt64Tests
 {
+    [Test]
+    public void CountDigits_ShouldReturn1_Given0()
+    {
+        const ulong value = 0;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn1_Given1()
+    {
+        const ulong value = 1;
+        const int expected = 1;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn2_Given10()
+    {
+        const ulong value = 10;
+        const int expected = 2;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void CountDigits_ShouldReturn3_Given199()
+    {
+        const ulong value = 199;
+        const int expected = 3;
+
+        int result = value.CountDigits();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
     [Test]
     public void DigitalRootShouldBeCorrect()
     {
diff --git a/X10D/src/Math/BigIntegerExtensions.cs b/X10D/src/Math/BigIntegerExtensions.cs
index 4ce5a0d..31f3884 100644
--- a/X10D/src/Math/BigIntegerExtensions.cs
+++ b/X10D/src/Math/BigIntegerExtensions.cs
@@ -10,6 +10,21 @@ namespace X10D.Math;
 /// </summary>
 public static class BigIntegerExtensions
 {
+    /// <summary>
+    ///     Returns the number of digits in the current integer.
+    /// </summary>
+    /// <param name="value">The value whose digit count to compute.</param>
+    /// <returns>The number of digits in <paramref name="value" />.</returns>
+    public static int CountDigits(this BigInteger value)
+    {
+        if (value == 0)
+        {
+            return 1;
+        }
+
+        return (int)(1 + BigInteger.Log10(BigInteger.Abs(value)));
+    }
+
     /// <summary>
     ///     Computes the digital root of this 8-bit integer.
     /// </summary>
diff --git a/X10D/src/Math/ByteExtensions.cs b/X10D/src/Math/ByteExtensions.cs
index 6a7db33..bc5a121 100644
--- a/X10D/src/Math/ByteExtensions.cs
+++ b/X10D/src/Math/ByteExtensions.cs
@@ -9,6 +9,21 @@ namespace X10D.Math;
 /// </summary>
 public static class ByteExtensions
 {
+    /// <summary>
+    ///     Returns the number of digits in the current 8-bit unsigned integer.
+    /// </summary>
+    /// <param name="value">The value whose digit count to compute.</param>
+    /// <returns>The number of digits in <paramref name="value" />.</returns>
+    public static int CountDigits(this byte value)
+    {
+        if (value == 0)
+        {
+            return 1;
+        }
+
+        return ((ulong)value).CountDigits();
+    }
+
     /// <summary>
     ///     Computes the digital root of this 8-bit integer.
     /// </summary>
diff --git a/X10D/src/Math/Int16Extensions.cs b/X10D/src/Math/Int16Extensions.cs
index 7896cf3..d0d354e 100644
--- a/X10D/src/Math/Int16Extensions.cs
+++ b/X10D/src/Math/Int16Extensions.cs
@@ -9,6 +9,21 @@ namespace X10D.Math;
 /// </summary>
 public static class Int16Extensions
 {
+    /// <summary>
+    ///     Returns the number of digits in the current 16-bit signed integer.
+    /// </summary>
+    /// <param name="value">The value whose digit count to compute.</param>
+    /// <returns>The number of digits in <paramref name="value" />.</returns>
+    public static int CountDigits(this short value)
+    {
+        if (value == 0)
+        {
+            return 1;
+        }
+
+        return ((long)value).CountDigits();
+    }
+
     /// <summary>
     ///     Computes the digital root of this 16-bit integer.
     /// </summary>
diff --git a/X10D/src/Math/Int32Extensions.cs b/X10D/src/Math/Int32Extensions.cs
index edaf0dd..95dc664 100644
--- a/X10D/src/Math/Int32Extensions.cs
+++ b/X10D/src/Math/Int32Extensions.cs
@@ -9,6 +9,21 @@ namespace X10D.Math;
 /// </summary>
 public static class Int32Extensions
 {
+    /// <summary>
+    ///     Returns the number of digits in the current 32-bit signed integer.
+    /// </summary>
+    /// <param name="value">The value whose digit count to compute.</param>
+    /// <returns>The number of digits in <paramref name="value" />.</returns>
+    public static int CountDigits(this int value)
+    {
+        if (value == 0)
+        {
+            return 1;
+        }
+
+        return ((long)value).CountDigits();
+    }
+
     /// <summary>
     ///     Computes the digital root of this 32-bit integer.
     /// </summary>
diff --git a/X10D/src/Math/Int64Extensions.cs b/X10D/src/Math/Int64Extensions.cs
index 5f888cc..317a379 100644
--- a/X10D/src/Math/Int64Extensions.cs
+++ b/X10D/src/Math/Int64Extensions.cs
@@ -9,6 +9,21 @@ namespace X10D.Math;
 /// </summary>
 public static class Int64Extensions
 {
+    /// <summary>
+    ///     Returns the number of digits in the current 64-bit signed integer.
+    /// </summary>
+    /// <param name="value">The value whose digit count to compute.</param>
+    /// <returns>The number of digits in <paramref name="value" />.</returns>
+    public static int CountDigits(this long value)
+    {
+        if (value == 0)
+        {
+            return 1;
+        }
+
+        return 1 + (int)System.Math.Floor(System.Math.Log10(System.Math.Abs(value)));
+    }
+
     /// <summary>
     ///     Computes the digital root of this 64-bit integer.
     /// </summary>
diff --git a/X10D/src/Math/SByteExtensions.cs b/X10D/src/Math/SByteExtensions.cs
index cc61037..68dde8d 100644
--- a/X10D/src/Math/SByteExtensions.cs
+++ b/X10D/src/Math/SByteExtensions.cs
@@ -10,6 +10,21 @@ namespace X10D.Math;
 [CLSCompliant(false)]
 public static class SByteExtensions
 {
+    /// <summary>
+    ///     Returns the number of digits in the current 8-bit signed integer.
+    /// </summary>
+    /// <param name="value">The value whose digit count to compute.</param>
+    /// <returns>The number of digits in <paramref name="value" />.</returns>
+    public static int CountDigits(this sbyte value)
+    {
+        if (value == 0)
+        {
+            return 1;
+        }
+
+        return ((long)value).CountDigits();
+    }
+
     /// <summary>
     ///     Computes the digital root of this 32-bit integer.
     /// </summary>
diff --git a/X10D/src/Math/UInt16Extensions.cs b/X10D/src/Math/UInt16Extensions.cs
index e118e58..73b97da 100644
--- a/X10D/src/Math/UInt16Extensions.cs
+++ b/X10D/src/Math/UInt16Extensions.cs
@@ -10,6 +10,21 @@ namespace X10D.Math;
 [CLSCompliant(false)]
 public static class UInt16Extensions
 {
+    /// <summary>
+    ///     Returns the number of digits in the current 16-bit signed integer.
+    /// </summary>
+    /// <param name="value">The value whose digit count to compute.</param>
+    /// <returns>The number of digits in <paramref name="value" />.</returns>
+    public static int CountDigits(this ushort value)
+    {
+        if (value == 0)
+        {
+            return 1;
+        }
+
+        return ((ulong)value).CountDigits();
+    }
+
     /// <summary>
     ///     Computes the digital root of the current 16-bit unsigned integer.
     /// </summary>
diff --git a/X10D/src/Math/UInt32Extensions.cs b/X10D/src/Math/UInt32Extensions.cs
index 79fed45..f74b14c 100644
--- a/X10D/src/Math/UInt32Extensions.cs
+++ b/X10D/src/Math/UInt32Extensions.cs
@@ -10,6 +10,21 @@ namespace X10D.Math;
 [CLSCompliant(false)]
 public static class UInt32Extensions
 {
+    /// <summary>
+    ///     Returns the number of digits in the current 32-bit unsigned integer.
+    /// </summary>
+    /// <param name="value">The value whose digit count to compute.</param>
+    /// <returns>The number of digits in <paramref name="value" />.</returns>
+    public static int CountDigits(this uint value)
+    {
+        if (value == 0)
+        {
+            return 1;
+        }
+
+        return ((ulong)value).CountDigits();
+    }
+
     /// <summary>
     ///     Computes the digital root of the current 32-bit unsigned integer.
     /// </summary>
diff --git a/X10D/src/Math/UInt64Extensions.cs b/X10D/src/Math/UInt64Extensions.cs
index 4bf9365..6c03a98 100644
--- a/X10D/src/Math/UInt64Extensions.cs
+++ b/X10D/src/Math/UInt64Extensions.cs
@@ -10,6 +10,21 @@ namespace X10D.Math;
 [CLSCompliant(false)]
 public static class UInt64Extensions
 {
+    /// <summary>
+    ///     Returns the number of digits in the current 64-bit unsigned integer.
+    /// </summary>
+    /// <param name="value">The value whose digit count to compute.</param>
+    /// <returns>The number of digits in <paramref name="value" />.</returns>
+    public static int CountDigits(this ulong value)
+    {
+        if (value == 0)
+        {
+            return 1;
+        }
+
+        return 1 + (int)System.Math.Floor(System.Math.Log10(System.Math.Abs((double)value)));
+    }
+
     /// <summary>
     ///     Computes the digital root of the current 64-bit unsigned integer.
     /// </summary>