Merge some new stuff

Author: LoneWandererProductions

CommonExtendedObjectsTests/CommonExtendedObjectsTests.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>net5.0</TargetFramework>
@@ -18,4 +18,4 @@
     <ProjectReference Include="..\Mathematics\Mathematics.csproj" />
   </ItemGroup>
 
-</Project>
+</Project>

CommonExtendedObjectsTests/DataItem.cs

@@ -13,79 +13,20 @@
 
 namespace CommonExtendedObjectsTests
 {
-    /// <inheritdoc cref="ObservableObject" />
     /// <summary>
     ///     Data Object
     /// </summary>
     internal sealed class DataItem
     {
-        /// <summary>
-        ///     The id.
-        /// </summary>
-        private int _id;
-
-        /// <summary>
-        ///     The name.
-        /// </summary>
-        private string _name;
-
         /// <summary>
         ///     Gets or sets the id.
         /// </summary>
-        internal int Id
-        {
-            get => _id;
-            set
-            {
-                if (_id == value)
-                {
-                    return;
-                }
-
-                _id = value;
-            }
-        }
+        internal int Id { get; set; }
 
         /// <summary>
         ///     Gets or sets the name.
         /// </summary>
-        internal string Name
-        {
-            get => _name;
-            set
-            {
-                if (_name == value)
-                {
-                    return;
-                }
-
-                _name = value;
-            }
-        }
-
-        /// <inheritdoc />
-        /// <summary>
-        ///     Indicates whether the current object is equal to another object of the same type.
-        /// </summary>
-        /// <param name="other">An object to compare with this object.</param>
-        /// <returns>
-        ///     <see langword="true" /> if the current object is equal to the <paramref name="other" /> parameter; otherwise,
-        ///     <see langword="false" />.
-        /// </returns>
-        internal bool Equals(DataItem other)
-        {
-            if (ReferenceEquals(null, other))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, other))
-            {
-                return true;
-            }
-
-            return _id == other._id && _name == other._name;
-        }
+        internal string Name { get; set; }
 
         /// <inheritdoc />
         /// <summary>
@@ -97,7 +38,7 @@ internal bool Equals(DataItem other)
         /// </returns>
         public override bool Equals(object obj)
         {
-            return ReferenceEquals(this, obj) || obj is DataItem other && Equals(other);
+            return ReferenceEquals(this, obj) || (obj is DataItem other && Equals(other));
         }
 
         /// <inheritdoc />
@@ -109,7 +50,7 @@ public override bool Equals(object obj)
         /// </returns>
         public override int GetHashCode()
         {
-            return HashCode.Combine(_id);
+            return HashCode.Combine(Id);
         }
     }
 }

CommonExtendedObjectsTests/HelperMethods.cs

@@ -47,7 +47,7 @@ internal static BaseMatrix MatrixTestOne(BaseMatrix mOne, BaseMatrix mTwo)
                         res += spanOne[iOne + k] * spanTwo[iTwo];
                     }
 
-                    spanResult[i * w + j] = res;
+                    spanResult[(i * w) + j] = res;
                 }
             }
 

CommonExtendedObjectsTests/ImmutableLookupMapTests.cs

@@ -21,17 +21,17 @@ namespace CommonExtendedObjectsTests
     public class PerformanceTests
     {
         /// <summary>
-        /// The data
+        ///     The data
         /// </summary>
         private Dictionary<int, string> _data;
 
         /// <summary>
-        /// The immutable lookup map
+        ///     The immutable lookup map
         /// </summary>
         private ImmutableLookupMap<int, string> _immutableLookupMap;
 
         /// <summary>
-        /// The read only dictionary
+        ///     The read only dictionary
         /// </summary>
         private ReadOnlyDictionary<int, string> _readOnlyDictionary;
 

CommonExtendedObjectsTests/IntArrayTests.cs

@@ -17,35 +17,41 @@ namespace CommonExtendedObjectsTests
     public class IntArrayTests
     {
         /// <summary>
-        /// The size
+        ///     The size
         /// </summary>
         private const int Size = 1_000_000;
 
         /// <summary>
-        /// Indexings the should get and set values correctly.
+        ///     Indexing the should get and set values correctly.
         /// </summary>
         [TestMethod]
         public void IndexingShouldGetAndSetValuesCorrectly()
         {
             var arr = new IntArray(5);
-            for (int i = 0; i < arr.Length; i++)
+            for (var i = 0; i < arr.Length; i++)
+            {
                 arr[i] = i * 10;
+            }
 
-            for (int i = 0; i < arr.Length; i++)
+            for (var i = 0; i < arr.Length; i++)
+            {
                 Assert.AreEqual(i * 10, arr[i]);
+            }
 
             arr.Dispose();
         }
 
         /// <summary>
-        /// Removes at should remove element and shift left.
+        ///     Removes at should remove element and shift left.
         /// </summary>
         [TestMethod]
         public void RemoveAtShouldRemoveElementAndShiftLeft()
         {
             var arr = new IntArray(5);
-            for (int i = 0; i < arr.Length; i++)
+            for (var i = 0; i < arr.Length; i++)
+            {
                 arr[i] = i;
+            }
 
             arr.RemoveAt(2);
 
@@ -56,7 +62,7 @@ public void RemoveAtShouldRemoveElementAndShiftLeft()
         }
 
         /// <summary>
-        /// Resizes the should change length and preserve old data.
+        ///     Resizes the should change length and preserve old data.
         /// </summary>
         [TestMethod]
         public void ResizeShouldChangeLengthAndPreserveOldData()
@@ -77,25 +83,29 @@ public void ResizeShouldChangeLengthAndPreserveOldData()
         }
 
         /// <summary>
-        /// Clears the should zero out all elements.
+        ///     Clears the should zero out all elements.
         /// </summary>
         [TestMethod]
         public void ClearShouldZeroOutAllElements()
         {
             var arr = new IntArray(4);
-            for (int i = 0; i < arr.Length; i++)
+            for (var i = 0; i < arr.Length; i++)
+            {
                 arr[i] = 42;
+            }
 
             arr.Clear();
 
-            for (int i = 0; i < arr.Length; i++)
+            for (var i = 0; i < arr.Length; i++)
+            {
                 Assert.AreEqual(0, arr[i]);
+            }
 
             arr.Dispose();
         }
 
         /// <summary>
-        /// Compares the int array vs int array dot net performance.
+        ///     Compares the int array vs int array dot net performance.
         /// </summary>
         [TestMethod]
         public void CompareIntArrayvsIntArrayDotNetPerformance()
@@ -106,12 +116,16 @@ public void CompareIntArrayvsIntArrayDotNetPerformance()
             var intArray = new IntArray(Size);
             stopwatch.Restart();
 
-            for (int i = 0; i < Size; i++)
+            for (var i = 0; i < Size; i++)
+            {
                 intArray[i] = i;
+            }
 
             long intArraySum = 0;
-            for (int i = 0; i < Size; i++)
+            for (var i = 0; i < Size; i++)
+            {
                 intArraySum += intArray[i];
+            }
 
             stopwatch.Stop();
             var customTime = stopwatch.ElapsedMilliseconds;
@@ -123,12 +137,16 @@ public void CompareIntArrayvsIntArrayDotNetPerformance()
             var nativeArray = new int[Size];
             stopwatch.Restart();
 
-            for (int i = 0; i < Size; i++)
+            for (var i = 0; i < Size; i++)
+            {
                 nativeArray[i] = i;
+            }
 
             long nativeSum = 0;
-            for (int i = 0; i < Size; i++)
+            for (var i = 0; i < Size; i++)
+            {
                 nativeSum += nativeArray[i];
+            }
 
             stopwatch.Stop();
             var nativeTime = stopwatch.ElapsedMilliseconds;
@@ -190,5 +208,72 @@ private static void RunIndexingTest(IUnmanagedArray<int> arr)
 
             arr.Dispose();
         }
+
+        /// <summary>
+        ///     Removes the multiple should remove sequential indices.
+        /// </summary>
+        [TestMethod]
+        public void RemoveMultipleShouldRemoveSequentialIndices()
+        {
+            var arr = new IntArray(10);
+            for (var i = 0; i < arr.Length; i++)
+            {
+                arr[i] = i + 1; // [1..10]
+            }
+
+            var toRemove = new[] { 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 (var i = 0; i < arr.Length; i++)
+            {
+                arr[i] = i + 1; // [1..10]
+            }
+
+            var toRemove = new[] { 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 (var i = 0; i < arr.Length; i++)
+            {
+                Assert.AreEqual(expected[i], arr[i]);
+            }
+
+            arr.Dispose();
+        }
     }
 }