renamed Pow10 to Factor

Author: petesramek

src/PolylineAlgorithm/FormatterBuilder.cs

@@ -81,7 +81,7 @@ public FormatterBuilder<TValue, TPolyline> AddValue(string name, Func<TValue, do
             throw new ArgumentException($"A rule with the name '{name}' has already been added.", nameof(name));
         }
 
-        _rules.Add(new FormatterRule<TValue>(name, (long)Pow10.GetFactor(precision), selector));
+        _rules.Add(new FormatterRule<TValue>(name, (long)Factor.Get(precision), selector));
 
         return this;
     }

src/PolylineAlgorithm/Internal/Pow10.cs src/PolylineAlgorithm/Internal/Factor.cssrc/PolylineAlgorithm/Internal/Pow10.cs renamed to src/PolylineAlgorithm/Internal/Factor.cs

@@ -9,11 +9,11 @@ namespace PolylineAlgorithm.Internal;
 /// This class caches common powers of 10 (10^0 through 10^9) for efficient lookup,
 /// falling back to <see cref="Math.Pow"/> for larger exponents.
 /// </remarks>
-internal static class Pow10 {
+internal static class Factor {
     /// <summary>
     /// Pre-computed powers of 10 from 10^0 to 10^9.
     /// </summary>
-    private static readonly uint[] _pow10 = [1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000];
+    private static readonly uint[] _factors = [1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000];
 
     /// <summary>
     /// Returns the power of 10 for the specified precision level.
@@ -32,9 +32,9 @@ internal static class Pow10 {
     /// <exception cref="OverflowException">
     /// Thrown if the computed value exceeds <see cref="uint.MaxValue"/>.
     /// </exception>
-    public static uint GetFactor(uint precision) {
+    public static uint Get(uint precision) {
         checked {
-            return precision < _pow10.Length ? _pow10[precision] : (uint)Math.Pow(10, precision);
+            return precision < _factors.Length ? _factors[precision] : (uint)Math.Pow(10, precision);
         }
     }
 }

src/PolylineAlgorithm/PolylineEncoding.cs

@@ -71,7 +71,7 @@ public static long Normalize(double value, uint precision = 5) {
             return (long)Math.Truncate(value);
         }
 
-        uint factor = Pow10.GetFactor(precision);
+        uint factor = Factor.Get(precision);
 
         const double Epsilon = 1e-9;
 
@@ -126,7 +126,7 @@ public static double Denormalize(long value, uint precision = 5) {
             return value;
         }
 
-        uint factor = Pow10.GetFactor(precision);
+        uint factor = Factor.Get(precision);
 
         checked {
 

…neAlgorithm.Tests/Internal/Pow10Tests.cs …eAlgorithm.Tests/Internal/FactorTests.cstests/PolylineAlgorithm.Tests/Internal/Pow10Tests.cs renamed to tests/PolylineAlgorithm.Tests/Internal/FactorTests.cs tests/PolylineAlgorithm.Tests/Internal/Pow10Tests.cs renamed to tests/PolylineAlgorithm.Tests/Internal/FactorTests.cs

@@ -8,12 +8,12 @@ namespace PolylineAlgorithm.Tests.Internal;
 using PolylineAlgorithm.Internal;
 
 /// <summary>
-/// Tests for <see cref="Pow10"/>.
+/// Tests for <see cref="Factor"/>.
 /// </summary>
 [TestClass]
-public sealed class Pow10Tests {
+public sealed class FactorTests {
     /// <summary>
-    /// Tests that GetFactor returns the correct power-of-ten factor for the given precision.
+    /// Tests that Get returns the correct power-of-ten factor for the given precision.
     /// </summary>
     [TestMethod]
     [DataRow(0u, 1u)]
@@ -26,24 +26,24 @@ public sealed class Pow10Tests {
     [DataRow(7u, 10000000u)]
     [DataRow(8u, 100000000u)]
     [DataRow(9u, 1000000000u)]
-    public void GetFactor_With_Valid_Precision_Returns_Expected_Value(uint precision, uint expected) {
+    public void Get_With_Valid_Precision_Returns_Expected_Value(uint precision, uint expected) {
         // Act
-        uint result = Pow10.GetFactor(precision);
+        uint result = Factor.Get(precision);
 
         // Assert
         Assert.AreEqual(expected, result);
     }
 
     /// <summary>
-    /// Tests that GetFactor throws <see cref="OverflowException"/> when precision causes overflow.
+    /// Tests that Get throws <see cref="OverflowException"/> when precision causes overflow.
     /// </summary>
     [TestMethod]
     [DataRow(10u)]
     [DataRow(15u)]
     [DataRow(20u)]
     [DataRow(uint.MaxValue)]
-    public void GetFactor_With_Overflowing_Precision_Throws_OverflowException(uint precision) {
+    public void Get_With_Overflowing_Precision_Throws_OverflowException(uint precision) {
         // Act & Assert
-        Assert.ThrowsExactly<OverflowException>(() => Pow10.GetFactor(precision));
+        Assert.ThrowsExactly<OverflowException>(() => Factor.Get(precision));
     }
 }