imporvements

Author: petesramek

src/PolylineAlgorithm/Abstraction/AbstractPolylineDecoder.cs

@@ -107,7 +107,7 @@ public IEnumerable<TCoordinate> Decode(TPolyline polyline) {
                 InvalidPolylineException.Throw(position);
             }
 
-            yield return CreateCoordinate(PolylineEncoding.Denormalize(latitude, CoordinateValueType.Latitude), PolylineEncoding.Denormalize(longitude, CoordinateValueType.Longitude));
+            yield return CreateCoordinate(PolylineEncoding.Denormalize(latitude, Options.Precision), PolylineEncoding.Denormalize(longitude, Options.Precision));
         }
 
         _logger

src/PolylineAlgorithm/Abstraction/AbstractPolylineEncoder.cs

@@ -13,7 +13,6 @@ namespace PolylineAlgorithm.Abstraction;
 using System;
 using System.Buffers;
 using System.Diagnostics;
-using System.Globalization;
 using System.Runtime.CompilerServices;
 
 /// <summary>
@@ -96,8 +95,8 @@ public TPolyline Encode(ReadOnlySpan<TCoordinate> coordinates) {
 
                 delta
                     .Next(
-                        PolylineEncoding.Normalize(GetLatitude(coordinates[i]), CoordinateValueType.Latitude),
-                        PolylineEncoding.Normalize(GetLongitude(coordinates[i]), CoordinateValueType.Longitude)
+                        PolylineEncoding.Normalize(GetLatitude(coordinates[i]), Options.Precision),
+                        PolylineEncoding.Normalize(GetLongitude(coordinates[i]), Options.Precision)
                     );
 
                 if (!PolylineEncoding.TryWriteValue(delta.Latitude, buffer, ref position)

src/PolylineAlgorithm/Coordinate.cs

@@ -5,13 +5,11 @@
 
 namespace PolylineAlgorithm;
 
-using PolylineAlgorithm.Internal;
 using PolylineAlgorithm.Properties;
 using System;
 using System.Diagnostics;
 using System.Globalization;
 using System.Runtime.InteropServices;
-using System.Text.Json.Serialization;
 #if NET8_0_OR_GREATER
 using System.Text;
 using System.Linq.Expressions;

src/PolylineAlgorithm/Extensions/PolylineEncoderExtensions.cs

@@ -5,12 +5,10 @@
 
 namespace PolylineAlgorithm.Extensions;
 
-using PolylineAlgorithm;
 using PolylineAlgorithm.Abstraction;
 using System;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
-using static PolylineAlgorithm.Internal.Defaults;
 
 /// <summary>
 /// Provides extension methods for the <see cref="IPolylineEncoder{TCoordinate, TPolyline}"/> interface to facilitate encoding geographic coordinates into polylines.

src/PolylineAlgorithm/PolylineEncoding.cs

@@ -8,10 +8,6 @@ namespace PolylineAlgorithm;
 using PolylineAlgorithm.Internal;
 using PolylineAlgorithm.Properties;
 using System;
-using System.Globalization;
-#if NET8_0_OR_GREATER
-using System.Text;
-#endif
 
 /// <summary>
 /// Provides methods for encoding and decoding polyline data, as well as utilities for normalizing and de-normalizing
@@ -22,34 +18,13 @@ namespace PolylineAlgorithm;
 /// coordinates. It also provides validation utilities to ensure values conform to expected ranges for latitude and
 /// longitude.</remarks>
 public static class PolylineEncoding {
-#if NET8_0_OR_GREATER
-    private static readonly CompositeFormat _argumentCannotBeCoordinateValueTypeMessageFormat = CompositeFormat.Parse(ExceptionMessageResource.ArgumentCannotBeCoordinateValueTypeMessageFormat);
-#else
-    private static readonly string _argumentCannotBeCoordinateValueTypeMessageFormat = ExceptionMessageResource.ArgumentCannotBeCoordinateValueTypeMessageFormat;
-#endif
-
-
-    /// <summary>
-    /// Gets the midpoint rounding strategy used when normalizing coordinate values.
-    /// </summary>
-    /// <remarks>
-    /// This property defines how rounding is performed during the normalization process in the <see cref="Normalize"/> method.
-    /// The value is set to <see cref="MidpointRounding.AwayFromZero"/>, which means that when a number is halfway between two others,
-    /// it is rounded toward the nearest number that is away from zero.
-    /// </remarks>
-    /// <value>
-    /// <see cref="MidpointRounding.AwayFromZero"/>
-    /// </value>
-    public static MidpointRounding Rounding { get; } = MidpointRounding.AwayFromZero;
-
     /// <summary>
     /// Normalizes a geographic coordinate value to an integer representation based on the specified precision.
     /// </summary>
     /// <remarks>
     /// <para>
     /// This method converts a floating-point coordinate value into a normalized integer by multiplying it by 10 raised
-    /// to the power of the specified precision, then rounding the result using the <see cref="Rounding"/> strategy
-    /// (<see cref="MidpointRounding.AwayFromZero"/>).
+    /// to the power of the specified precision, then rounding the result using the specified <paramref name="rounding"/> strategy.
     /// </para>
     /// <para>
     /// For example, with the default precision of 5:
@@ -71,6 +46,10 @@ public static class PolylineEncoding {
     /// The value is multiplied by 10^<paramref name="precision"/> before rounding. 
     /// Default is 5, which is standard for polyline encoding.
     /// </param>
+    /// <param name="rounding">
+    /// The rounding strategy to use when converting the scaled value to an integer.
+    /// Default is <see cref="MidpointRounding.AwayFromZero"/>, which rounds midpoint values to the nearest number away from zero.
+    /// </param>
     /// <returns>
     /// An integer representing the normalized value. Returns <c>0</c> if the input <paramref name="value"/> is <c>0.0</c>.
     /// </returns>
@@ -80,7 +59,7 @@ public static class PolylineEncoding {
     /// <exception cref="OverflowException">
     /// Thrown when the normalized result exceeds the range of a 32-bit signed integer during the conversion from double to int.
     /// </exception>
-    public static int Normalize(double value, uint precision = 5) {
+    public static int Normalize(double value, uint precision = 5, MidpointRounding rounding = MidpointRounding.AwayFromZero) {
         // Validate that the value is finite and not NaN or Infinity.
         if (!double.IsFinite(value)) {
             throw new ArgumentOutOfRangeException(nameof(value), ExceptionMessageResource.ArgumentValueMustBeFiniteNumber);
@@ -91,8 +70,10 @@ public static int Normalize(double value, uint precision = 5) {
             return 0;
         }
 
+        uint factor = Pow10.GetFactor(precision);
+
         checked {
-            return (int)Math.Round(precision == 0 ? value : value * Math.Pow(10, precision), Rounding);
+            return (int)Math.Round(precision == 0 ? value : value * factor, rounding);
         }
     }
 
@@ -102,11 +83,11 @@ public static int Normalize(double value, uint precision = 5) {
     /// <remarks>
     /// <para>
     /// This method reverses the normalization process performed by <see cref="Normalize"/>. It takes an integer value and converts it
-    /// to a double by dividing by 10 raised to the power of the specified precision. If the precision is 0, the value is returned as a double
+    /// to a double by dividing it by 10 raised to the power of the specified precision. If the precision is 0, the value is returned as a double
     /// without division.
     /// </para>
     /// <para>
-    /// The calculation is performed inside a <c>checked</c> block to ensure that any arithmetic overflow is detected and an <see cref="OverflowException"/> is thrown.
+    /// The calculation is performed inside a <see langword="checked"/> block to ensure that any arithmetic overflow is detected and an <see cref="OverflowException"/> is thrown.
     /// </para>
     /// <para>
     /// For example, with a precision of 5:
@@ -132,14 +113,14 @@ public static int Normalize(double value, uint precision = 5) {
     /// Thrown if the arithmetic operation overflows during conversion.
     /// </exception>
     public static double Denormalize(int value, uint precision = 5) {
-        // Return fast if the value is zero, return 0.0 as the denormalized value.
         if (value == 0) {
             return 0.0;
         }
 
-        // Using 'checked' to ensure overflow exceptions are thrown if the result exceeds numeric limits.
+        uint factor = Pow10.GetFactor(precision);
+
         checked {
-            return precision == 0 ? value : value / Math.Pow(10, precision);
+            return precision == 0 ? value : (double)value / factor;
         }
     }
 
@@ -242,7 +223,7 @@ public static bool TryReadValue(ref int delta, ReadOnlyMemory<char> buffer, ref
     /// </returns>
     public static bool TryWriteValue(int delta, Span<char> buffer, ref int position) {
         // Validate that the position and required space for write is within the bounds of the buffer.
-        if (buffer.Slice(position).Length < GetRequiredBufferSize(delta)) {
+        if (buffer[position..].Length < GetRequiredBufferSize(delta)) {
             return false;
         }
 

src/PolylineAlgorithm/PolylineEncodingOptions.cs

@@ -33,6 +33,15 @@ public sealed class PolylineEncodingOptions {
     /// </remarks>
     public int StackAllocLimit { get; internal set; } = 512;
 
+    /// <summary>
+    /// Gets the precision used for polyline encoding.
+    /// </summary>
+    /// <remarks>
+    /// The precision determines the number of decimal places to use when encoding coordinates.
+    /// The default value is 5, which is commonly used for geographic coordinates.
+    /// </remarks>
+    public uint Precision { get; internal set; } = 5;
+
     /// <summary>
     /// Returns type name of a logger factory for debugging purposes.
     /// </summary>

src/PolylineAlgorithm/PolylineEncodingOptionsBuilder.cs

@@ -22,6 +22,7 @@ public sealed class PolylineEncodingOptionsBuilder {
 #else
     private static readonly string _stackAllocLimitMustBeEqualOrGreaterThanMessageFormat = ExceptionMessageResource.StackAllocLimitMustBeEqualOrGreaterThanMessageFormat;
 #endif
+    private uint _precision = 5;
     private int _stackAllocLimit = 512;
     private ILoggerFactory _loggerFactory = NullLoggerFactory.Instance;
 
@@ -45,28 +46,50 @@ public static PolylineEncodingOptionsBuilder Create() {
     /// </returns>
     public PolylineEncodingOptions Build() {
         return new PolylineEncodingOptions {
+            Precision = _precision,
             StackAllocLimit = _stackAllocLimit,
             LoggerFactory = _loggerFactory,
         };
     }
 
     /// <summary>
-    /// Sets the buffer size for encoding operations.
+    /// Configures the buffer size used for stack allocation during polyline encoding operations.
     /// </summary>
     /// <param name="stackAllocLimit">
-    /// The maximum buffer size. Must be greater than 11.
+    /// The maximum buffer size to use for stack allocation. Must be greater than or equal to 1.
     /// </param>
     /// <returns>
-    /// The current builder instance.
+    /// Returns the current <see cref="PolylineEncodingOptionsBuilder"/> instance for method chaining.
     /// </returns>
-    /// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="stackAllocLimit"/> is less than or equal to 11.</exception>
+    /// <exception cref="ArgumentOutOfRangeException">
+    /// Thrown if <paramref name="stackAllocLimit"/> is less than 1.
+    /// </exception>
+    /// <remarks>
+    /// This method allows customization of the internal buffer size for encoding, which can impact performance and memory usage.
+    /// </remarks>
     public PolylineEncodingOptionsBuilder WithStackAllocLimit(int stackAllocLimit) {
         const int minStackAllocLimit = 1;
+
         _stackAllocLimit = stackAllocLimit >= minStackAllocLimit ? stackAllocLimit : throw new ArgumentOutOfRangeException(nameof(stackAllocLimit), string.Format(CultureInfo.InvariantCulture, _stackAllocLimitMustBeEqualOrGreaterThanMessageFormat, minStackAllocLimit));
 
         return this;
     }
 
+    /// <summary>
+    /// Sets the precision for encoding values.
+    /// </summary>
+    /// <param name="precision">
+    /// The number of decimal places to use for encoding values. Default is 5.
+    /// </param>
+    /// <returns>
+    /// The current builder instance.
+    /// </returns>
+    public PolylineEncodingOptionsBuilder WithPrecision(uint precision) {
+        _precision = precision;
+
+        return this;
+    }
+
     /// <summary>
     /// Sets the logger factory for logging during encoding operations.
     /// </summary>

src/PolylineAlgorithm/Pow10.cs

@@ -0,0 +1,38 @@
+namespace PolylineAlgorithm;
+
+using System;
+
+/// <summary>
+/// Provides optimized calculation of powers of 10 for precision-based operations.
+/// </summary>
+/// <remarks>
+/// 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>
+public static class Pow10 {
+    /// <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 };
+
+    /// <summary>
+    /// Gets the multiplication factor for a given precision level.
+    /// </summary>
+    /// <param name="precision">The precision level (exponent for base 10).</param>
+    /// <returns>
+    /// The power of 10 corresponding to the specified precision (10^precision).
+    /// </returns>
+    /// <remarks>
+    /// For precision values 0-9, returns pre-computed values for optimal performance.
+    /// For larger values, computes the result using <see cref="Math.Pow"/>.
+    /// The operation is performed in a checked context to detect arithmetic overflow.
+    /// </remarks>
+    /// <exception cref="OverflowException">
+    /// Thrown when the computed power of 10 exceeds <see cref="uint.MaxValue"/>.
+    /// </exception>
+    public static uint GetFactor(uint precision) {
+        checked {
+            return precision < _pow10.Length ? _pow10[precision] : (uint)Math.Pow(10, precision);
+        }
+    }
+}