itermediate commit

Author: Petr Sramek

PolylineAlgorithm.sln

@@ -0,0 +1,15 @@
+<Solution>
+  <Folder Name="/benchmarks/">
+    <Project Path="benchmarks/PolylineAlgorithm.Benchmarks/PolylineAlgorithm.Benchmarks.csproj" />
+    <Project Path="benchmarks/PolylineAlgorithm.Comparison.Benchmarks/PolylineAlgorithm.Comparison.Benchmarks.csproj" />
+  </Folder>
+  <Folder Name="/samples/" />
+  <Folder Name="/src/">
+    <Project Path="src/PolylineAlgorithm.Abstraction/PolylineAlgorithm.Abstraction.csproj" />
+    <Project Path="src/PolylineAlgorithm.IO.Pipelines/PolylineAlgorithm.IO.Pipelines.csproj" />
+    <Project Path="src/PolylineAlgorithm/PolylineAlgorithm.csproj" />
+  </Folder>
+  <Folder Name="/tests/">
+    <Project Path="tests/PolylineAlgorithm.Tests/PolylineAlgorithm.Tests.csproj" />
+  </Folder>
+</Solution>

PolylineAlgorithm.slnx

@@ -12,7 +12,7 @@ namespace PolylineAlgorithm.Benchmarks;
 using System.Text;
 
 /// <summary>
-/// Benchmarks for the <see cref="Polyline"/> struct.
+/// Benchmarks for the <see cref="PolylineValue"/> struct.
 /// </summary>
 [RankColumn]
 public class PolylineBenchmark {
@@ -23,24 +23,24 @@ public class PolylineBenchmark {
 
 #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
     /// <summary>
-    /// Gets the string value representing the encoded polyline.
+    /// Gets the character array representing the encoded polyline.
     /// </summary>
-    public string StringValue { get; private set; }
+    public char[] CharArrayValue { get; private set; }
 
     /// <summary>
-    /// Gets the character array representing the encoded polyline.
+    /// Gets the read-only memory representing the encoded polyline.
     /// </summary>
-    public char[] CharArray { get; private set; }
+    public ReadOnlyMemory<char> MemoryValue { get; private set; }
 
     /// <summary>
     /// Gets the read-only memory representing the encoded polyline.
     /// </summary>
-    public ReadOnlyMemory<char> Memory { get; private set; }
+    public Polyline PolylineValue { get; private set; }
 
     /// <summary>
-    /// Gets the read-only memory representing the encoded polyline.
+    /// Gets the string value representing the encoded polyline.
     /// </summary>
-    public Polyline Polyline { get; private set; }
+    public string StringValue { get; private set; }
 
 #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
 
@@ -50,10 +50,10 @@ public class PolylineBenchmark {
     /// </summary>
     [GlobalSetup]
     public void SetupData() {
-        Polyline = ValueProvider.GetPolyline(Length);
-        StringValue = Polyline.ToString();
-        CharArray = StringValue.ToArray();
-        Memory = CharArray.AsMemory();
+        PolylineValue = ValueProvider.GetPolyline(Length);
+        StringValue = PolylineValue.ToString();
+        CharArrayValue = StringValue.ToArray();
+        MemoryValue = CharArrayValue.AsMemory();
     }
 
     /// <summary>
@@ -75,7 +75,7 @@ public Polyline Polyline_FromString() {
     [Benchmark]
     public Polyline Polyline_FromCharArray() {
         var polyline = Polyline
-            .FromCharArray(CharArray);
+            .FromCharArray(CharArrayValue);
 
         return polyline;
     }
@@ -87,7 +87,7 @@ public Polyline Polyline_FromCharArray() {
     [Benchmark]
     public Polyline Polyline_FromMemory() {
         var polyline = Polyline
-            .FromMemory(Memory);
+            .FromMemory(MemoryValue);
 
         return polyline;
     }
@@ -98,23 +98,23 @@ public Polyline Polyline_FromMemory() {
     /// <returns>The encoded polyline.</returns>
     [Benchmark]
     public string Polyline_ToString() {
-        var stringValue = Polyline
+        var stringValue = PolylineValue
             .ToString();
 
         return stringValue;
     }
 
-    /// <summary>
-    /// Benchmarks the encoding of an enumeration of coordinates into a polyline.
-    /// </summary>
-    /// <returns>The encoded polyline.</returns>
-    [Benchmark]
-    public long Polyline_GetCoordinateCount() {
-        var coordinateCount = Polyline
-            .GetCoordinateCount();
+    ///// <summary>
+    ///// Benchmarks the encoding of an enumeration of coordinates into a polyline.
+    ///// </summary>
+    ///// <returns>The encoded polyline.</returns>
+    //[Benchmark]
+    //public long Polyline_GetCoordinateCount() {
+    //    var coordinateCount = PolylineValue
+    //        .GetCoordinateCount();
 
-        return coordinateCount;
-    }
+    //    return coordinateCount;
+    //}
 
 
     /// <summary>
@@ -123,9 +123,9 @@ public long Polyline_GetCoordinateCount() {
     /// <returns>The encoded polyline.</returns>
     [Benchmark]
     public void Polyline_CopyTo() {
-        var destination = new char[Polyline.Length];
+        var destination = new char[PolylineValue.Length];
 
-        Polyline
+        PolylineValue
             .CopyTo(destination);
 
         destination
@@ -138,8 +138,8 @@ public void Polyline_CopyTo() {
     /// <returns>The encoded polyline.</returns>
     [Benchmark]
     public bool Polyline_Equals() {
-        var equals = Polyline
-            .Equals(Polyline);
+        var equals = PolylineValue
+            .Equals(PolylineValue);
 
         return equals;
     }

benchmarks/PolylineAlgorithm.Benchmarks/PolylineBenchmark.cs

@@ -19,7 +19,7 @@ namespace PolylineAlgorithm.Comparison.Benchmarks;
 /// </summary>
 [RankColumn]
 public class PolylineEncoderBenchmark {
-    [Params(1, 10, 100, 1_000, 10_000, 100_000, 1_000_000)]
+    [Params(1, 10, 100, 250, 500, 1_000, 2_500, 5_000, 7_500, 10_000, 15_000, 20_000, 25_000, 50_000, 75_000, 100_000, 250_000, 500_000, 750_000, 1_000_000)]
     public int N;
 
 #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.

benchmarks/PolylineAlgorithm.Comparison.Benchmarks/PolylineEncoderBenchmark.cs

@@ -36,20 +36,20 @@ public async Task EncodeAsync(PipeReader reader, PipeWriter writer, Cancellation
             throw new ArgumentNullException(nameof(writer));
         }
 
-        CoordinateVariance variance;
-        Coordinate current = Coordinate.Default;
+        CoordinateVariance variance = new();
 
-        while (await Formatter.TryReadAsync(reader, out Coordinate next, cancellation).ConfigureAwait(false)) {
-            variance = CoordinateVariance.Calculate(current, next);
+        while (await Formatter.TryReadAsync(reader, out Coordinate coordinate, cancellation).ConfigureAwait(false)) {
+            (int Latitude, int Longitude) next = (PolylineEncoding.Default.Normalize(coordinate.Latitude), PolylineEncoding.Default.Normalize(coordinate.Longitude));
+
+            variance
+                .Next(next);
 
             Process(writer, variance.Latitude, _buffer);
             Process(writer, variance.Longitude, _buffer);
 
             await writer
                 .FlushAsync(cancellation)
                 .ConfigureAwait(false);
-
-            current = next;
         }
 
         await CompleteAsync(reader, writer)

src/PolylineAlgorithm.IO.Pipelines/PolylineEncoderPipe.cs

@@ -2,31 +2,29 @@
 
 using System;
 using System.Diagnostics;
+using System.Runtime.InteropServices;
 
 [DebuggerDisplay($"{{{nameof(ToString)}(),nq}}")]
-public readonly ref struct CoordinateVariance {
+[StructLayout(LayoutKind.Sequential)]
+public struct CoordinateVariance {
+    private (int Latitude, int Longitude) _current = (0, 0);
+
     private CoordinateVariance(int latitude, int longitude) {
         Latitude = latitude;
         Longitude = longitude;
     }
 
-    public int Latitude { get; }
-    public int Longitude { get; }
+    public int Latitude { get; private set; }
 
-    public static CoordinateVariance Create(int latitude, int longitude) {
-        return new CoordinateVariance(latitude, longitude);
-    }
+    public int Longitude { get; private set; }
 
-    public static CoordinateVariance Calculate(Coordinate initial, Coordinate next) {
-        int latitude = Variance(Round(initial.Latitude), Round(next.Latitude));
-        int longitude = Variance(Round(initial.Longitude), Round(next.Longitude));
+    public void Next(in (int Latitude, int Longitude) next) {
+        Latitude = Variance(_current.Latitude, next.Latitude);
+        Longitude = Variance(_current.Longitude, next.Longitude);
 
-        return new CoordinateVariance(latitude, longitude);
+        _current = next;
     }
 
-    public override readonly string ToString()
-        => $"Variance: {{ Latitude: {Latitude}, Longitude: {Longitude} }}";
-
     private static int Variance(int initial, int next) => (initial, next) switch {
         (0, 0) => 0,
         (0, _) => next,
@@ -37,5 +35,6 @@ public override readonly string ToString()
         ( > 0, > 0) => next - initial,
     };
 
-    private static int Round(double value) => (int)Math.Round(value * Defaults.Algorithm.Precision);
+    public override readonly string ToString()
+        => $"Variance: {{ Latitude: {Latitude}, Longitude: {Longitude} }}";
 }