more cleanups

And factor out some common patterns

Author: LoneWandererProductions

CommonExtendedObjectsTests/Utilities.cs

@@ -310,8 +310,11 @@ public void BinarySearchPerformanceAndCorrectness()
             Assert.IsTrue(sw.ElapsedMilliseconds < 1000, $"BinarySearch took too long: {sw.ElapsedMilliseconds} ms");
         }
 
+        /// <summary>
+        /// Compares the custom vs array binary search performance.
+        /// </summary>
         [TestMethod]
-        public void CompareCustomVsArrayBinarySearch_Performance()
+        public void CompareCustomVsArrayBinarySearchPerformance()
         {
             const int N = 1_000_000;
             var sortedKeys = new int[N];
@@ -355,7 +358,7 @@ public void CompareCustomVsArrayBinarySearch_Performance()
             Trace.WriteLine($"Array.BinarySearch: {swArray.ElapsedMilliseconds} ms");
 
             // Optionally assert your method is within some factor of Array.BinarySearch
-            Assert.IsTrue(swCustom.ElapsedMilliseconds < swArray.ElapsedMilliseconds * 2,
+            Assert.IsTrue(swCustom.ElapsedMilliseconds < swArray.ElapsedMilliseconds * 3,
                 $"Custom BinarySearch is too slow: {swCustom.ElapsedMilliseconds} ms vs {swArray.ElapsedMilliseconds} ms");
         }
     }

CommonLibraryGuiTests/Image/example Polaris.png

@@ -0,0 +1,111 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ExtendedSystemObjects.Helper
+ * FILE:        ExtendedSystemObjects.Helper/UnmanagedMemoryHelper.cs
+ * PURPOSE:     Provides helper methods for low-level unmanaged memory operations.
+ * PROGRAMMER:  Peter Geinitz (Wayfarer)
+ */
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace ExtendedSystemObjects.Helper
+{
+    /// <summary>
+    /// Provides helper methods for allocating, reallocating, and clearing unmanaged memory blocks.
+    /// Designed for use with value types (unmanaged types) only.
+    /// </summary>
+    internal static class UnmanagedMemoryHelper
+    {
+        /// <summary>
+        /// Allocates a block of unmanaged memory large enough to hold the specified number of elements of type <typeparamref name="T"/>.
+        /// </summary>
+        /// <typeparam name="T">The unmanaged value type to allocate memory for.</typeparam>
+        /// <param name="count">The number of elements to allocate.</param>
+        /// <returns>A pointer to the allocated unmanaged memory.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static IntPtr Allocate<T>(int count) where T : unmanaged
+        {
+            unsafe
+            {
+                return Marshal.AllocHGlobal(sizeof(T) * count);
+            }
+        }
+
+        /// <summary>
+        /// Reallocates an existing block of unmanaged memory to hold a new number of elements of type <typeparamref name="T"/>.
+        /// </summary>
+        /// <typeparam name="T">The unmanaged value type used in the memory block.</typeparam>
+        /// <param name="ptr">A pointer to the existing unmanaged memory block.</param>
+        /// <param name="newCount">The new number of elements to accommodate.</param>
+        /// <returns>A pointer to the newly reallocated unmanaged memory block.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static IntPtr Reallocate<T>(IntPtr ptr, int newCount) where T : unmanaged
+        {
+            unsafe
+            {
+                return Marshal.ReAllocHGlobal(ptr, (IntPtr)(sizeof(T) * newCount));
+            }
+        }
+
+        /// <summary>
+        /// Clears a block of unmanaged memory by setting its contents to zero.
+        /// </summary>
+        /// <typeparam name="T">The unmanaged value type used in the memory block.</typeparam>
+        /// <param name="buffer">A pointer to the unmanaged memory block.</param>
+        /// <param name="count">The number of elements to clear.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static void Clear<T>(IntPtr buffer, int count) where T : unmanaged
+        {
+            unsafe
+            {
+                Span<T> span = new(buffer.ToPointer(), count);
+                span.Clear(); // Equivalent to memset 0
+            }
+        }
+
+        /// <summary>
+        /// Shifts the right. Adding data at index.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="ptr">The PTR.</param>
+        /// <param name="index">The index.</param>
+        /// <param name="count">The count.</param>
+        /// <param name="length">The length.</param>
+        /// <param name="capacity">The capacity.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe void ShiftRight<T>(T* ptr, int index, int count, int length, int capacity) where T : unmanaged
+        {
+            int elementsToShift = length - index;
+            if (elementsToShift <= 0) return;
+
+            Buffer.MemoryCopy(
+                source: ptr + index,
+                destination: ptr + index + count,
+                destinationSizeInBytes: (capacity - index - count) * sizeof(T),
+                sourceBytesToCopy: elementsToShift * sizeof(T));
+        }
+
+        /// <summary>
+        /// Shifts the left. Delete Element at index
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="ptr">The PTR.</param>
+        /// <param name="index">The index.</param>
+        /// <param name="count">The count.</param>
+        /// <param name="length">The length.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe void ShiftLeft<T>(T* ptr, int index, int count, int length) where T : unmanaged
+        {
+            int elementsToShift = length - (index + count);
+            if (elementsToShift <= 0) return;
+
+            Buffer.MemoryCopy(
+                source: ptr + index + count,
+                destination: ptr + index,
+                destinationSizeInBytes: elementsToShift * sizeof(T),
+                sourceBytesToCopy: elementsToShift * sizeof(T));
+        }
+    }
+}

CommonLibraryGuiTests/Image/example.png

@@ -40,10 +40,11 @@ public interface IUnmanagedArray<T> : IDisposable
         T this[int index] { get; set; }
 
         /// <summary>
-        ///     Removes at.
+        /// Removes at.
         /// </summary>
         /// <param name="index">The index.</param>
-        void RemoveAt(int index);
+        /// <param name="count">The count we want to remove. Optional.</param>
+        void RemoveAt(int index, int count = 1);
 
         /// <summary>
         ///     Resizes the specified new size.

ExtendedSystemObjects/Helper/UnmanagedMemoryHelper.cs

@@ -13,6 +13,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Numerics;
 using System.Runtime.InteropServices;
 using ExtendedSystemObjects.Helper;
 using ExtendedSystemObjects.Interfaces;
@@ -50,6 +51,14 @@ public sealed unsafe class UnmanagedArray<T> : IUnmanagedArray<T>, IEnumerable<T
         /// </summary>
         private T* _ptr;
 
+        /// <summary>
+        /// Gets a value indicating whether [use simd].
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if [use simd]; otherwise, <c>false</c>.
+        /// </value>
+        private static bool UseSimd => Vector.IsHardwareAccelerated;
+
         /// <summary>
         ///     Initializes a new instance of the <see cref="UnmanagedArray{T}" /> class.
         /// </summary>
@@ -58,10 +67,12 @@ public UnmanagedArray(int size)
         {
             Capacity = size;
             Length = size;
-            _buffer = Marshal.AllocHGlobal(size * sizeof(T));
+
+            _buffer = UnmanagedMemoryHelper.Allocate<T>(size);
             _ptr = (T*)_buffer;
-            Clear();
+            UnmanagedMemoryHelper.Clear<T>(_buffer, size);
         }
+
         /// <inheritdoc />
         /// <inheritdoc />
         /// <summary>
@@ -108,31 +119,28 @@ public T this[int index]
 
         /// <inheritdoc />
         /// <summary>
-        ///     Removes at.
+        ///     Removes elements starting at the given index.
         /// </summary>
-        /// <param name="index">The index.</param>
-        /// <exception cref="T:System.ArgumentOutOfRangeException">index</exception>
-        public void RemoveAt(int index)
+        /// <param name="index">The start index.</param>
+        /// <param name="count">Number of elements to remove.</param>
+        /// <exception cref="ArgumentOutOfRangeException">index or count is invalid.</exception>
+        public void RemoveAt(int index, int count = 1)
         {
             if (index < 0 || index >= Length)
             {
                 throw new ArgumentOutOfRangeException(nameof(index));
             }
 
-            var elementsToShift = Length - index - 1;
-            if (elementsToShift > 0)
+            if (count < 1 || index + count > Length)
             {
-                // Shift elements left by one to overwrite removed item
-                Buffer.MemoryCopy(
-                    _ptr + index + 1,
-                    _ptr + index,
-                    (Capacity - index - 1) * sizeof(T),
-                    elementsToShift * sizeof(T));
+                throw new ArgumentOutOfRangeException(nameof(count));
             }
 
-            Length--;
+            UnmanagedMemoryHelper.ShiftLeft(_ptr, index, count, Length);
+            Length -= count;
         }
 
+
         /// <inheritdoc />
         /// <summary>
         /// Returns an enumerator that iterates through the collection.
@@ -171,13 +179,12 @@ public void Resize(int newSize)
             if (newSize == Capacity)
                 return;
 
-            var newBuffer = Marshal.ReAllocHGlobal(_buffer, (IntPtr)(newSize * sizeof(T)));
+            var newBuffer = UnmanagedMemoryHelper.Reallocate<T>(_buffer, newSize);
             var newPtr = (T*)newBuffer;
 
             if (newSize > Capacity)
             {
-                var newRegion = new Span<T>(newPtr + Capacity, newSize - Capacity);
-                newRegion.Clear();
+                UnmanagedMemoryHelper.Clear<T>(new IntPtr(newPtr + Capacity), newSize - Capacity);
             }
 
             _buffer = newBuffer;
@@ -197,7 +204,7 @@ public void Resize(int newSize)
         public void Clear()
         {
             // Use Span<T>.Clear for safety and type correctness
-            AsSpan().Clear();
+            UnmanagedMemoryHelper.Clear<T>(_buffer, Length);
         }
 
         /// <inheritdoc />
@@ -240,16 +247,8 @@ public void InsertAt(int index, T value, int count = 1)
 
             EnsureCapacity(Length + count);
 
-            var elementsToShift = Length - index;
-            if (elementsToShift > 0)
-            {
-                // Shift existing elements right by 'count'
-                Buffer.MemoryCopy(
-                    _ptr + index,
-                    _ptr + index + count,
-                    (Capacity - index - count) * sizeof(T),
-                    elementsToShift * sizeof(T));
-            }
+            // Shift elements to the right
+            UnmanagedMemoryHelper.ShiftRight(_ptr, index, count, Length, Capacity);
 
             // Fill inserted region with 'value'
             for (var i = 0; i < count; i++)