more z curve

Author: eocron

Eocron.Algorithms.Tests/SpaceCurveTests.cs

@@ -8,28 +8,52 @@ namespace Eocron.Algorithms.Tests
     public class SpaceCurveTests
     {
         [Test]
-        public void ZCurve_Check_Base3()
+        public void ZCurve_Check_Single_Base3()
         {
-            var input = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
-            var actual = ZCurve.Interleave(input, 3);
+            var input = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
+            var actual = ZCurve.InterleaveSingle(input, 3);
             actual.Should().Equal(new[] {1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12});
         }
 
         [Test]
-        public void ZCurve_Check_Base2()
+        public void ZCurve_Check_Single_Base2()
         {
-            var input = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
-            var actual = ZCurve.Interleave(input, 2);
+            var input = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
+            var actual = ZCurve.InterleaveSingle(input, 2);
             actual.Should().Equal(new[] {1, 7, 2, 8, 3, 9, 4, 10, 5, 11, 6, 12});
         }
 
         [Test]
-        public void ZCurve_Check_Multiple()
+        public void ZCurve_Check_Multiple_SameSize()
         {
-            var input1 = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
-            var input2 = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
-            var actual = ZCurve.Interleave(input1, input2);
+            var input1 = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
+            var input2 = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
+            var actual = ZCurve.InterleaveMultiple(input1, input2);
             actual.Should().Equal(new[] {1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12});
         }
+        
+        
+                
+        [Test]
+        public void ZCurve_Check_Multiple_DifferentSize()
+        {
+            var input1 = new[] { 1, 2, 3, 4, 5 };
+            var input2 = new[] { 6 };
+            var input3 = new[] { 7 };
+            var actual = ZCurve.InterleaveMultiple(input1, input2, input3);
+            actual.Should().Equal(new[] {1, 2, 3, 4, 5, 6, 7});
+        }
+        
+        [Test]
+        public void ZCurve_Check_Multiple_DifferentSize_Gcd()
+        {
+            var input1 = new[] { 1, 2, 3, 4 };
+            var input2 = new[] { 6, 7 };
+            var input3 = new[] { 8, 9 };
+            var actual = ZCurve.InterleaveMultiple(input1, input2, input3);
+            actual.Should().Equal(new[] {1, 2, 6, 8, 3, 4, 7, 9});
+            actual = ZCurve.InterleaveMultiple(input3, input2, input1);
+            actual.Should().Equal(new[] {8, 6, 1, 2, 9, 7, 3, 4});
+        }
     }
 }

Eocron.Algorithms/SpaceCurves/ZCurve.cs

@@ -4,15 +4,16 @@
 
 namespace Eocron.Algorithms.SpaceCurves
 {
+    
     public static class ZCurve
     {
-        public static T[] Interleave<T>(IReadOnlyCollection<T> items, int m)
+        public static T[] InterleaveSingle<T>(IReadOnlyCollection<T> items, int m)
         {
-            return Interleave<T>(items, items.Count, m);
+            return InterleaveSingle(items, items.Count, m);
         }
 
 
-        public static T[] Interleave<T>(IEnumerable<T> items, int size, int m)
+        public static T[] InterleaveSingle<T>(IEnumerable<T> items, int size, int m)
         {
             if (size % m != 0)
             {
@@ -29,24 +30,63 @@ public static T[] Interleave<T>(IEnumerable<T> items, int size, int m)
             return output;
         }
 
-        public static T[] Interleave<T>(params IReadOnlyCollection<T>[] itemSequences)
+        public static T[] InterleaveMultiple<T>(params IReadOnlyCollection<T>[] itemSequences)
         {
             var itemSize = itemSequences[0].Count;
             if (itemSequences.Any(x=> x.Count != itemSize))
             {
-                throw new ArgumentOutOfRangeException(nameof(itemSequences), "Sequences should have same size");
+                return InterleaveMultipleDifferentSize(itemSequences);
             }
 
             var m = itemSequences.Length;
 
-            return Interleave(itemSequences.SelectMany(x => x), itemSize * m, m);
+            return InterleaveSingle(itemSequences.SelectMany(x => x), itemSize * m, m);
         }
 
-        public static int GetInterleavedIndex(int idx, int n, int m)
+        private static T[] InterleaveMultipleDifferentSize<T>(params IReadOnlyCollection<T>[] itemSequences)
+        {
+            var (steps, size) = GetChunkSizeAndFinalSize(itemSequences);
+            var chunked = itemSequences.Select((x,i)=> x.Chunk(steps[i]));
+            var m = itemSequences.Length;
+            var interleaved = InterleaveSingle(chunked.SelectMany(x => x), size, m);
+            return interleaved.SelectMany(x => x).ToArray();
+        }
+
+        private static (int[], int) GetChunkSizeAndFinalSize<T>(IEnumerable<IReadOnlyCollection<T>> itemSequences)
+        {
+            var steps = itemSequences.Select(x => x.Count).ToArray();
+            var gcd = GreatestCommonDivisor(steps);
+            for (var i = 0; i < steps.Length; i++)
+            {
+                steps[i] /= gcd;
+            }
+
+            return (steps, gcd * steps.Length);
+        }
+
+        private static int GetInterleavedIndex(int idx, int n, int m)
         {
             var i = idx / n;
             var j = idx % n;
             return j * m + i;
         }
+
+        private static int GreatestCommonDivisor(IEnumerable<int> items)
+        {
+            return items.Aggregate(GreatestCommonDivisor);
+        }
+        
+        private static int GreatestCommonDivisor(int a, int b)
+        {
+            while (a != 0 && b != 0)
+            {
+                if (a > b)
+                    a %= b;
+                else
+                    b %= a;
+            }
+
+            return a | b;
+        }
     }
 }