Add some more experimental stuff

Author: LoneWandererProductions

CommonExtendedObjectsTests/IntArrayTests.cs

@@ -144,5 +144,68 @@ public void CompareIntArrayvsIntArrayDotNetPerformance()
             Assert.IsTrue(customTime < 2000, $"IntArray took too long: {customTime}ms");
             Assert.IsTrue(nativeTime < 2000, $"int[] took too long: {nativeTime}ms");
         }
+
+        /// <summary>
+        /// Removes the multiple should remove sequential indices.
+        /// </summary>
+        [TestMethod]
+        public void RemoveMultipleShouldRemoveSequentialIndices()
+        {
+            var arr = new IntArray(10);
+            for (int i = 0; i < arr.Length; i++)
+                arr[i] = i + 1; // [1..10]
+
+            var toRemove = new int[] { 3, 4, 5 }; // remove elements at indices 3,4,5 (4th,5th,6th elements)
+
+            var sw = Stopwatch.StartNew();
+            arr.RemoveMultiple(toRemove);
+            sw.Stop();
+
+            Console.WriteLine($"RemoveMultiple (sequential) took {sw.ElapsedTicks} ticks");
+
+            Assert.AreEqual(7, arr.Length);
+
+            // Remaining should be: 1,2,3,7,8,9,10 (indices:0,1,2,3,4,5,6)
+            Assert.AreEqual(1, arr[0]);
+            Assert.AreEqual(2, arr[1]);
+            Assert.AreEqual(3, arr[2]);
+            Assert.AreEqual(7, arr[3]);
+            Assert.AreEqual(8, arr[4]);
+            Assert.AreEqual(9, arr[5]);
+            Assert.AreEqual(10, arr[6]);
+
+            arr.Dispose();
+        }
+
+        /// <summary>
+        /// Removes the multiple should remove non sequential indices.
+        /// </summary>
+        [TestMethod]
+        public void RemoveMultipleShouldRemoveNonSequentialIndices()
+        {
+            var arr = new IntArray(10);
+            for (int i = 0; i < arr.Length; i++)
+                arr[i] = i + 1; // [1..10]
+
+            var toRemove = new int[] { 1, 3, 6 }; // remove elements at indices 1,3,6
+
+            var sw = Stopwatch.StartNew();
+            arr.RemoveMultiple(toRemove);
+            sw.Stop();
+
+            Console.WriteLine($"RemoveMultiple (non-sequential) took {sw.ElapsedTicks} ticks");
+
+            Assert.AreEqual(7, arr.Length);
+
+            // Remaining elements: indices 0,2,4,5,7,8,9
+            // Values: 1, 3, 5, 6, 8, 9, 10
+            int[] expected = { 1, 3, 5, 6, 8, 9, 10 };
+            for (int i = 0; i < arr.Length; i++)
+            {
+                Assert.AreEqual(expected[i], arr[i]);
+            }
+
+            arr.Dispose();
+        }
     }
 }

ExtendedSystemObjects/IntArray.cs

@@ -11,6 +11,7 @@
 // ReSharper disable MemberCanBeInternal
 
 using System;
+using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
@@ -102,6 +103,90 @@ public void RemoveAt(int index)
             _length--; // Reduces logical size, but memory is not freed
         }
 
+
+        /// <summary>
+        /// Remove multiple indices from IntArray efficiently
+        /// Assumes indicesToRemove contains zero or more indices (in any order)
+        /// Removes all specified indices from the array
+        /// </summary>
+        /// <param name="indicesToRemove">The indices to remove.</param>
+        public void RemoveMultiple(int[] indicesToRemove)
+        {
+            if (indicesToRemove == null || indicesToRemove.Length == 0)
+                return;
+
+            // Sort indices ascending (important!)
+            Array.Sort(indicesToRemove);
+
+            // Validate indices within bounds
+#if DEBUG
+            foreach (var idx in indicesToRemove)
+                if (idx < 0 || idx >= _length)
+                    throw new IndexOutOfRangeException($"Index {idx} is out of range.");
+#endif
+
+            if (IsSequential(indicesToRemove))
+            {
+                // Optimized path for continuous block removal
+                int start = indicesToRemove[0];
+                int count = indicesToRemove.Length;
+
+                // Move tail elements left by count positions
+                int tailLength = _length - (start + count);
+                if (tailLength > 0)
+                {
+                    Buffer.MemoryCopy(
+                        _ptr + start + count,
+                        _ptr + start,
+                        tailLength * sizeof(int),
+                        tailLength * sizeof(int)
+                    );
+                }
+
+                _length -= count;
+            }
+            else
+            {
+                // General multi-block removal, no assumption on indices continuity
+
+                int srcIndex = 0;
+                int dstIndex = 0;
+
+                foreach (var removeIndex in indicesToRemove)
+                {
+                    int lengthToCopy = removeIndex - srcIndex;
+
+                    if (lengthToCopy > 0)
+                    {
+                        Buffer.MemoryCopy(
+                            _ptr + srcIndex,
+                            _ptr + dstIndex,
+                            (_length - dstIndex) * sizeof(int),
+                            lengthToCopy * sizeof(int)
+                        );
+                        dstIndex += lengthToCopy;
+                    }
+
+                    srcIndex = removeIndex + 1;
+                }
+
+                // Copy remaining tail block after last removed index
+                int tailLength = _length - srcIndex;
+                if (tailLength > 0)
+                {
+                    Buffer.MemoryCopy(
+                        _ptr + srcIndex,
+                        _ptr + dstIndex,
+                        (_length - dstIndex) * sizeof(int),
+                        tailLength * sizeof(int)
+                    );
+                    dstIndex += tailLength;
+                }
+
+                _length = dstIndex;
+            }
+        }
+
         /// <summary>
         /// Resizes the internal array to the specified new size.
         /// Contents will be preserved up to the minimum of old and new size.
@@ -132,6 +217,27 @@ public void Clear()
         /// <returns>A <see cref="Span{Int32}"/> over the internal buffer.</returns>
         public Span<int> AsSpan() => new((void*)_buffer, _length);
 
+        /// <summary>
+        /// Determines whether the specified sorted indices is sequential.
+        /// </summary>
+        /// <param name="sortedIndices">The sorted indices.</param>
+        /// <returns>
+        ///   <c>true</c> if the specified sorted indices is sequential; otherwise, <c>false</c>.
+        /// </returns>
+        private static bool IsSequential(IReadOnlyList<int> sortedIndices)
+        {
+            if (sortedIndices is not {Count: > 1})
+                return true;
+
+            for (int i = 1; i < sortedIndices.Count; i++)
+            {
+                if (sortedIndices[i] != sortedIndices[i - 1] + 1)
+                    return false;
+            }
+
+            return true;
+        }
+
         /// <summary>
         /// Finalizes an instance of the <see cref="IntArray"/> class.
         /// </summary>