Implements logical operations for indexSets

Author: benbierens

Tests/FrameworkTests/Utils/RunLengthEncodingLogicalTests.cs

@@ -5,6 +5,56 @@ namespace FrameworkTests.Utils
     [TestFixture]
     public class RunLengthEncodingLogicalTests
     {
+        [Test]
+        public void EqualityTest()
+        {
+            var setA = new IndexSet([1, 2, 3, 4]);
+            var setB = new IndexSet([1, 2, 3, 4]);
+
+            Assert.That(setA, Is.EqualTo(setB));
+            Assert.That(setA == setB);
+        }
+
+        [Test]
+        public void InequalityTest1()
+        {
+            var setA = new IndexSet([1, 2, 4, 5]);
+            var setB = new IndexSet([1, 2, 3, 4]);
+
+            Assert.That(setA, Is.Not.EqualTo(setB));
+            Assert.That(setA != setB);
+        }
+
+        [Test]
+        public void InequalityTest2()
+        {
+            var setA = new IndexSet([1, 2, 3]);
+            var setB = new IndexSet([1, 2, 3, 4]);
+
+            Assert.That(setA, Is.Not.EqualTo(setB));
+            Assert.That(setA != setB);
+        }
+
+        [Test]
+        public void InequalityTest3()
+        {
+            var setA = new IndexSet([2, 3, 4, 5]);
+            var setB = new IndexSet([1, 2, 3, 4]);
+
+            Assert.That(setA, Is.Not.EqualTo(setB));
+            Assert.That(setA != setB);
+        }
+
+        [Test]
+        public void InequalityTest()
+        {
+            var setA = new IndexSet([2, 3, 4]);
+            var setB = new IndexSet([1, 2, 3, 4]);
+
+            Assert.That(setA, Is.Not.EqualTo(setB));
+            Assert.That(setA != setB);
+        }
+
         [Test]
         public void Overlap()
         {
@@ -46,28 +96,59 @@ public partial class IndexSet
     {
         public IndexSet Overlap(IndexSet other)
         {
-            return this;
+            var result = new IndexSet();
+            Iterate(i =>
+            {
+                if (other.IsSet(i)) result.Set(i);
+            });
+            return result;
         }
 
         public IndexSet Merge(IndexSet other)
         {
-            return this;
+            var result = new IndexSet();
+            Iterate(result.Set);
+            other.Iterate(result.Set);
+            return result;
         }
 
         public IndexSet Without(IndexSet other)
         {
-            return this;
+            var result = new IndexSet();
+            Iterate(i =>
+            {
+                if (!other.IsSet(i)) result.Set(i);
+            });
+            return result;
         }
 
         public override bool Equals(object? obj)
         {
-            return obj is IndexSet set &&
-                   EqualityComparer<SortedList<int, Run>>.Default.Equals(runs, set.runs);
+            if (obj is IndexSet set)
+            {
+                if (set.runs.Count != runs.Count) return false;
+                foreach (var pair in runs)
+                {
+                    if (!set.runs.ContainsKey(pair.Key)) return false;
+                    if (set.runs[pair.Key] != pair.Value) return false;
+                }
+                return true;
+            }
+            return false;
         }
 
         public override int GetHashCode()
         {
             return HashCode.Combine(runs);
         }
+
+        public static bool operator ==(IndexSet? obj1, IndexSet? obj2)
+        {
+            if (ReferenceEquals(obj1, obj2)) return true;
+            if (ReferenceEquals(obj1, null)) return false;
+            if (ReferenceEquals(obj2, null)) return false;
+            return obj1.Equals(obj2);
+        }
+        public static bool operator !=(IndexSet? obj1, IndexSet? obj2) => !(obj1 == obj2);
     }
 }

Tests/FrameworkTests/Utils/RunLengthEncodingRunTests.cs

@@ -5,6 +5,36 @@ namespace FrameworkTests.Utils
     [TestFixture]
     public class RunLengthEncodingRunTests
     {
+        [Test]
+        public void EqualityTest()
+        {
+            var runA = new Run(1, 4);
+            var runB = new Run(1, 4);
+
+            Assert.That(runA, Is.EqualTo(runB));
+            Assert.That(runA == runB);
+        }
+
+        [Test]
+        public void InequalityTest1()
+        {
+            var runA = new Run(1, 4);
+            var runB = new Run(1, 5);
+
+            Assert.That(runA, Is.Not.EqualTo(runB));
+            Assert.That(runA != runB);
+        }
+
+        [Test]
+        public void InequalityTest2()
+        {
+            var runA = new Run(1, 4);
+            var runB = new Run(2, 4);
+
+            Assert.That(runA, Is.Not.EqualTo(runB));
+            Assert.That(runA != runB);
+        }
+
         [Test]
         [Combinatorial]
         public void RunIncludes(
@@ -31,23 +61,58 @@ public void RunIncludes(
         }
 
         [Test]
-        public void RunExpandToInclude()
+        public void RunExpandThrowsWhenIndexNotAdjacent()
         {
             var run = new Run(2, 3);
+            Assert.That(!run.Includes(1));
             Assert.That(run.Includes(2));
             Assert.That(run.Includes(4));
             Assert.That(!run.Includes(5));
 
-            Assert.That(run.ExpandToInclude(1), Is.False);
-            Assert.That(run.ExpandToInclude(2), Is.False);
-            Assert.That(run.ExpandToInclude(4), Is.False);
-            Assert.That(run.ExpandToInclude(6), Is.False);
+            Assert.That(() => run.ExpandToInclude(0), Throws.TypeOf<Exception>());
+            Assert.That(() => run.ExpandToInclude(6), Throws.TypeOf<Exception>());
+        }
+
+        [Test]
+        public void RunExpandThrowsWhenIndexAlreadyIncluded()
+        {
+            var run = new Run(2, 3);
+            Assert.That(!run.Includes(1));
+            Assert.That(run.Includes(2));
+            Assert.That(run.Includes(4));
+            Assert.That(!run.Includes(5));
 
-            Assert.That(run.ExpandToInclude(5), Is.True);
+            Assert.That(() => run.ExpandToInclude(2), Throws.TypeOf<Exception>());
+            Assert.That(() => run.ExpandToInclude(3), Throws.TypeOf<Exception>());
+        }
+
+        [Test]
+        public void RunExpandToIncludeAfter()
+        {
+            var run = new Run(2, 3);
+            var update = run.ExpandToInclude(5);
+            Assert.That(update, Is.Not.Null);
+            Assert.That(update.NewRuns.Length, Is.EqualTo(0));
+            Assert.That(update.RemoveRuns.Length, Is.EqualTo(0));
             Assert.That(run.Includes(5));
             Assert.That(!run.Includes(6));
         }
 
+        [Test]
+        public void RunExpandToIncludeBefore()
+        {
+            var run = new Run(2, 3);
+            var update = run.ExpandToInclude(1);
+
+            Assert.That(update, Is.Not.Null);
+            Assert.That(update.NewRuns.Length, Is.EqualTo(1));
+            Assert.That(update.RemoveRuns.Length, Is.EqualTo(1));
+
+            Assert.That(update.RemoveRuns[0], Is.SameAs(run));
+            Assert.That(update.NewRuns[0].Start, Is.EqualTo(1));
+            Assert.That(update.NewRuns[0].Length, Is.EqualTo(4));
+        }
+
         [Test]
         public void RunCanUnsetLastIndex()
         {
@@ -98,7 +163,7 @@ public void CanIterateIndices()
         {
             var run = new Run(2, 4);
             var seen = new List<int>();
-            run.Iterate(i => seen.Add(i));
+            run.Iterate(seen.Add);
 
             CollectionAssert.AreEqual(new[] { 2, 3, 4, 5 }, seen);
         }
@@ -120,14 +185,22 @@ public bool Includes(int index)
             return index >= Start && index < (Start + Length);
         }
 
-        public bool ExpandToInclude(int index)
+        public RunUpdate ExpandToInclude(int index)
         {
+            if (Includes(index)) throw new Exception("Run already includes this index. Run: {ToString()} index: {index}");
             if (index == (Start + Length))
             {
                 Length++;
-                return true;
+                return new RunUpdate();
             }
-            return false;
+            if (index == (Start - 1))
+            {
+                return new RunUpdate(
+                    newRuns: [new Run(Start - 1, Length + 1)],
+                    removeRuns: [this]
+                );
+            }
+            throw new Exception($"Run cannot expand to include index. Run: {ToString()} index: {index}");
         }
 
         public RunUpdate Unset(int index)
@@ -145,8 +218,8 @@ public RunUpdate Unset(int index)
                     return new RunUpdate(Array.Empty<Run>(), new[] { this });
                 }
                 return new RunUpdate(
-                    newRuns: new[] { new Run(Start + 1, Length - 1) },
-                    removeRuns: new[] { this }
+                    newRuns: [new Run(Start + 1, Length - 1)],
+                    removeRuns: [this]
                 );
             }
 
@@ -160,7 +233,10 @@ public RunUpdate Unset(int index)
             // Split:
             var newRunLength = (Start + Length - 1) - index;
             Length = index - Start;
-            return new RunUpdate(new[] { new Run(index + 1, newRunLength) }, Array.Empty<Run>());
+            return new RunUpdate(
+                newRuns: [new Run(index + 1, newRunLength)],
+                removeRuns: Array.Empty<Run>()
+            );
         }
 
         public void Iterate(Action<int> action)
@@ -170,6 +246,32 @@ public void Iterate(Action<int> action)
                 action(Start + i);
             }
         }
+
+        public override string ToString()
+        {
+            return $"[{Start},{Length}]";
+        }
+
+        public override bool Equals(object? obj)
+        {
+            return obj is Run run &&
+                   Start == run.Start &&
+                   Length == run.Length;
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(Start, Length);
+        }
+
+        public static bool operator ==(Run? obj1, Run? obj2)
+        {
+            if (ReferenceEquals(obj1, obj2)) return true;
+            if (ReferenceEquals(obj1, null)) return false;
+            if (ReferenceEquals(obj2, null)) return false;
+            return obj1.Equals(obj2);
+        }
+        public static bool operator !=(Run? obj1, Run? obj2) => !(obj1 == obj2);
     }
 
     public class RunUpdate