feat(int64): change namespace to NumSharp.Utilities and fix compilation

This commit completes the UnmanagedSpan implementation for long indexing support:

**Namespace Change**
- Changed all SpanSource files from `namespace System` to `namespace NumSharp.Utilities`
- Added `using System;` to all files for standard types

**Removed .NET Internal Dependencies**
- Removed internal attributes: [NonVersionable], [Intrinsic], [RequiresUnsafe],
  [CompExactlyDependsOn], [OverloadResolutionPriority]
- Replaced RuntimeHelpers.QCall P/Invoke with NativeMemory.Copy/Fill
- Removed Unsafe.IsOpportunisticallyAligned (NET9+ only)
- Removed BulkMoveWithWriteBarrier (internal .NET method)

**Added `unmanaged` Constraint**
- Added `where T : unmanaged` to UnmanagedSpan<T>, ReadOnlyUnmanagedSpan<T>
- Added constraint to UnmanagedSpanDebugView<T> and helper methods
- Removed CastUp<TDerived> method (for reference types only)

**Deleted Unnecessary Files (~85K lines)**
- UnmanagedSpanExtensions*.cs (5 files) - advanced string/char features
- UnmanagedSpanHelpers.BinarySearch.cs - search helpers
- UnmanagedSpanHelpers.Byte.cs, .Char.cs - type-specific helpers
- UnmanagedSpanHelpers.Packed.cs - SIMD packed operations
- UnmanagedSpanHelpers.T.cs - complex SIMD with ISimdVector<>
- Utilities/UnmanagedSpan.cs - old simple implementation (backup exists)

**Simplified Core Files**
- UnmanagedBuffer.cs: Simplified to only Memmove<T> for unmanaged types
- UnmanagedSpanHelpers.cs: Added vectorized Fill<T> method
- Fixed ulong→nuint conversions for Clear, Fill, CopyTo methods
- Fixed ToString() to use char* for string creation

**Remaining Files (7 files, ~52K lines)**
- UnmanagedSpan.cs - main type with long indexing
- ReadOnlyUnmanagedSpan.cs - read-only variant
- UnmanagedBuffer.cs - memory copy operations
- UnmanagedSpanHelpers.cs - ClearWithReferences, Reverse, Fill<T>
- UnmanagedSpanHelpers.ByteMemOps.cs - Memmove, ClearWithoutReferences
- UnmanagedSpanDebugView.cs - debugger visualization
- UnmanagedSpanThrowHelper.cs - exception helpers

Build: SUCCESS (4399 tests pass)

Author: Nucs

src/NumSharp.Core/Utilities/SpanSource/ReadOnlyUnmanagedSpan.cs

@@ -1,3 +1,4 @@
+using System;
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
@@ -15,18 +16,15 @@
 
 #pragma warning disable 0809 // Obsolete member 'UnmanagedSpan<T>.Equals(object)' overrides non-obsolete member 'object.Equals(object)'
 
-namespace System
+namespace NumSharp.Utilities
 {
     /// <summary>
     /// ReadOnlyUnmanagedSpan represents a contiguous region of arbitrary memory. Unlike arrays, it can point to either managed
     /// or native memory, or to memory allocated on the stack. It is type-safe and memory-safe.
     /// </summary>
     [DebuggerTypeProxy(typeof(UnmanagedSpanDebugView<>))]
     [DebuggerDisplay("{ToString(),raw}")]
-    [NonVersionable]
-    [NativeMarshalling(typeof(ReadOnlyUnmanagedSpanMarshaller<,>))]
-    [Intrinsic]
-    public readonly ref struct ReadOnlyUnmanagedSpan<T>
+    public readonly ref struct ReadOnlyUnmanagedSpan<T> where T : unmanaged
     {
         /// <summary>A byref or a native ptr.</summary>
         internal readonly ref T _reference;
@@ -101,7 +99,6 @@ public ReadOnlyUnmanagedSpan(T[]? array, int start, int length)
         /// </exception>
         [CLSCompliant(false)]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        [RequiresUnsafe]
         public unsafe ReadOnlyUnmanagedSpan(void* pointer, long length)
         {
             if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
@@ -142,9 +139,7 @@ internal ReadOnlyUnmanagedSpan(ref T reference, long length)
         /// </exception>
         public ref readonly T this[long index]
         {
-            [Intrinsic]
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            [NonVersionable]
             get
             {
                 if ((ulong)index >= (ulong)_length)
@@ -158,8 +153,6 @@ public ref readonly T this[long index]
         /// </summary>
         public long Length
         {
-            [Intrinsic]
-            [NonVersionable]
             get => _length;
         }
 
@@ -169,7 +162,6 @@ public long Length
         /// <value><see langword="true"/> if this span is empty; otherwise, <see langword="false"/>.</value>
         public bool IsEmpty
         {
-            [NonVersionable]
             get => _length == 0;
         }
 
@@ -217,17 +209,7 @@ public static implicit operator ReadOnlyUnmanagedSpan<T>(ArraySegment<T> segment
         /// </summary>
         public static ReadOnlyUnmanagedSpan<T> Empty => default;
 
-        /// <summary>
-        /// Casts a read-only span of <typeparamref name="TDerived"/> to a read-only span of <typeparamref name="T"/>.
-        /// </summary>
-        /// <typeparam name="TDerived">The element type of the source read-only span, which must be derived from <typeparamref name="T"/>.</typeparam>
-        /// <param name="items">The source read-only span. No copy is made.</param>
-        /// <returns>A read-only span with elements cast to the new type.</returns>
-        /// <remarks>This method uses a covariant cast, producing a read-only span that shares the same memory as the source. The relationships expressed in the type constraints ensure that the cast is a safe operation.</remarks>
-        public static ReadOnlyUnmanagedSpan<T> CastUp<TDerived>(ReadOnlyUnmanagedSpan<TDerived> items) where TDerived : class?, T
-        {
-            return new ReadOnlyUnmanagedSpan<T>(ref Unsafe.As<TDerived, T>(ref items._reference), items.Length);
-        }
+        // Note: CastUp<TDerived> method removed - not applicable for unmanaged types
 
         /// <summary>Gets an enumerator for this span.</summary>
         public Enumerator GetEnumerator() => new Enumerator(this);
@@ -308,13 +290,9 @@ public ref readonly T GetPinnableReference()
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void CopyTo(UnmanagedSpan<T> destination)
         {
-            // Using "if (!TryCopyTo(...))" results in two branches: one for the length
-            // check, and one for the result of TryCopyTo. Since these checks are equivalent,
-            // we can optimize by performing the check once ourselves then calling Memmove directly.
-
             if ((ulong)_length <= (ulong)destination.Length)
             {
-                UnmanagedBuffer.Memmove(ref destination._reference, ref _reference, (ulong)_length);
+                UnmanagedBuffer.Memmove(ref destination._reference, ref Unsafe.AsRef(in _reference), checked((nuint)_length));
             }
             else
             {
@@ -335,7 +313,7 @@ public bool TryCopyTo(UnmanagedSpan<T> destination)
             bool retVal = false;
             if ((ulong)_length <= (ulong)destination.Length)
             {
-                UnmanagedBuffer.Memmove(ref destination._reference, ref _reference, (ulong)_length);
+                UnmanagedBuffer.Memmove(ref destination._reference, ref Unsafe.AsRef(in _reference), checked((nuint)_length));
                 retVal = true;
             }
             return retVal;
@@ -353,13 +331,16 @@ public bool TryCopyTo(UnmanagedSpan<T> destination)
         /// For <see cref="ReadOnlyUnmanagedSpan{Char}"/>, returns a new instance of string that represents the characters pointed to by the span.
         /// Otherwise, returns a <see cref="string"/> with the name of the type and the number of elements.
         /// </summary>
-        public override string ToString()
+        public override unsafe string ToString()
         {
             if (typeof(T) == typeof(char))
             {
-                return new string(new ReadOnlyUnmanagedSpan<char>(ref Unsafe.As<T, char>(ref _reference), _length));
+                // For char spans, create string. Need to handle long length.
+                if (_length > int.MaxValue)
+                    return $"NumSharp.Utilities.ReadOnlyUnmanagedSpan<Char>[{_length}]";
+                return new string((char*)Unsafe.AsPointer(ref Unsafe.AsRef(in _reference)), 0, (int)_length);
             }
-            return $"System.ReadOnlyUnmanagedSpan<{typeof(T).Name}>[{_length}]";
+            return $"NumSharp.Utilities.ReadOnlyUnmanagedSpan<{typeof(T).Name}>[{_length}]";
         }
 
         /// <summary>

src/NumSharp.Core/Utilities/SpanSource/UnmanagedBuffer.cs

@@ -1,107 +1,23 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
+// Simplified for NumSharp - only supports unmanaged types (no reference type handling)
 
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
+using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using System.Threading;
 
-namespace System
+namespace NumSharp.Utilities
 {
+    /// <summary>
+    /// Provides low-level memory copy operations for unmanaged types.
+    /// </summary>
     public static partial class UnmanagedBuffer
     {
-        // Copies from one primitive array to another primitive array without
-        // respecting types.  This calls memmove internally.  The count and
-        // offset parameters here are in bytes.  If you want to use traditional
-        // array element indices and counts, use Array.Copy.
-        public static void BlockCopy(Array src, int srcOffset, Array dst, int dstOffset, int count)
-        {
-            ArgumentNullException.ThrowIfNull(src);
-            ArgumentNullException.ThrowIfNull(dst);
-
-            nuint uSrcLen = src.NativeLength;
-            if (src.GetType() != typeof(byte[]))
-            {
-                if (!src.GetCorElementTypeOfElementType().IsPrimitiveType())
-                    throw new ArgumentException(SR.Arg_MustBePrimArray, nameof(src));
-                uSrcLen *= (nuint)src.GetElementSize();
-            }
-
-            nuint uDstLen = uSrcLen;
-            if (src != dst)
-            {
-                uDstLen = dst.NativeLength;
-                if (dst.GetType() != typeof(byte[]))
-                {
-                    if (!dst.GetCorElementTypeOfElementType().IsPrimitiveType())
-                        throw new ArgumentException(SR.Arg_MustBePrimArray, nameof(dst));
-                    uDstLen *= (nuint)dst.GetElementSize();
-                }
-            }
-
-            ArgumentOutOfRangeException.ThrowIfNegative(srcOffset);
-            ArgumentOutOfRangeException.ThrowIfNegative(dstOffset);
-            ArgumentOutOfRangeException.ThrowIfNegative(count);
-
-            nuint uCount = (nuint)count;
-            nuint uSrcOffset = (nuint)srcOffset;
-            nuint uDstOffset = (nuint)dstOffset;
-
-            if ((uSrcLen < uSrcOffset + uCount) || (uDstLen < uDstOffset + uCount))
-                throw new ArgumentException(SR.Argument_InvalidOffLen);
-
-            Memmove(ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(dst), uDstOffset), ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(src), uSrcOffset), uCount);
-        }
-
-        public static int ByteLength(Array array)
-        {
-            ArgumentNullException.ThrowIfNull(array);
-
-            // Is it of primitive types?
-            if (!array.GetCorElementTypeOfElementType().IsPrimitiveType())
-                throw new ArgumentException(SR.Arg_MustBePrimArray, nameof(array));
-
-            nuint byteLength = array.NativeLength * (nuint)array.GetElementSize();
-
-            // This API is exposed both as UnmanagedBuffer.ByteLength and also used indirectly in argument
-            // checks for UnmanagedBuffer.GetByte/SetByte.
-            //
-            // If somebody called Get/SetByte on 2GB+ arrays, there is a decent chance that
-            // the computation of the index has overflowed. Thus we intentionally always
-            // throw on 2GB+ arrays in Get/SetByte argument checks (even for indices <2GB)
-            // to prevent people from running into a trap silently.
-
-            return checked((int)byteLength);
-        }
-
-        public static byte GetByte(Array array, int index)
-        {
-            // array argument validation done via ByteLength
-            if ((uint)index >= (uint)ByteLength(array))
-            {
-                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
-            }
-
-            return Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index);
-        }
-
-        public static void SetByte(Array array, int index, byte value)
-        {
-            // array argument validation done via ByteLength
-            if ((uint)index >= (uint)ByteLength(array))
-            {
-                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
-            }
-
-            Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index) = value;
-        }
-
-        // The attributes on this method are chosen for best JIT performance.
-        // Please do not edit unless intentional.
+        /// <summary>
+        /// Copies bytes from source to destination using unmanaged memory copy.
+        /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [CLSCompliant(false)]
-        [RequiresUnsafe]
         public static unsafe void MemoryCopy(void* source, void* destination, long destinationSizeInBytes, long sourceBytesToCopy)
         {
             if (sourceBytesToCopy > destinationSizeInBytes)
@@ -112,11 +28,11 @@ public static unsafe void MemoryCopy(void* source, void* destination, long desti
             Memmove(ref *(byte*)destination, ref *(byte*)source, checked((nuint)sourceBytesToCopy));
         }
 
-        // The attributes on this method are chosen for best JIT performance.
-        // Please do not edit unless intentional.
+        /// <summary>
+        /// Copies bytes from source to destination using unmanaged memory copy.
+        /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [CLSCompliant(false)]
-        [RequiresUnsafe]
         public static unsafe void MemoryCopy(void* source, void* destination, ulong destinationSizeInBytes, ulong sourceBytesToCopy)
         {
             if (sourceBytesToCopy > destinationSizeInBytes)
@@ -127,88 +43,30 @@ public static unsafe void MemoryCopy(void* source, void* destination, ulong dest
             Memmove(ref *(byte*)destination, ref *(byte*)source, checked((nuint)sourceBytesToCopy));
         }
 
-#if !MONO // Mono BulkMoveWithWriteBarrier is in terms of elements (not bytes) and takes a type handle.
-
-        [Intrinsic]
+        /// <summary>
+        /// Copies elements from source to destination.
+        /// For unmanaged types only - does not handle reference types.
+        /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static unsafe void Memmove<T>(ref T destination, ref T source, nuint elementCount)
-        {
-            if (!RuntimeHelpers.IsReferenceOrContainsReferences<T>())
-            {
-                // Blittable memmove
-                UnmanagedSpanHelpers.Memmove(
-                    ref Unsafe.As<T, byte>(ref destination),
-                    ref Unsafe.As<T, byte>(ref source),
-                    elementCount * (nuint)sizeof(T));
-            }
-            else
-            {
-                // Non-blittable memmove
-                BulkMoveWithWriteBarrier(
-                    ref Unsafe.As<T, byte>(ref destination),
-                    ref Unsafe.As<T, byte>(ref source),
-                    elementCount * (nuint)sizeof(T));
-            }
-        }
-
-        // The maximum block size to for BulkMoveWithWriteBarrierInternal FCall. This is required to avoid GC starvation.
-#if DEBUG // Stress the mechanism in debug builds
-        private const uint BulkMoveWithWriteBarrierChunk = 0x400;
-#else
-        private const uint BulkMoveWithWriteBarrierChunk = 0x4000;
-#endif
-
-        internal static void BulkMoveWithWriteBarrier(ref byte destination, ref byte source, nuint byteCount)
+        internal static unsafe void Memmove<T>(ref T destination, ref T source, nuint elementCount) where T : unmanaged
         {
-            if (byteCount <= BulkMoveWithWriteBarrierChunk)
-            {
-                BulkMoveWithWriteBarrierInternal(ref destination, ref source, byteCount);
-                Thread.FastPollGC();
-            }
-            else
-            {
-                BulkMoveWithWriteBarrierBatch(ref destination, ref source, byteCount);
-            }
+            UnmanagedSpanHelpers.Memmove(
+                ref Unsafe.As<T, byte>(ref destination),
+                ref Unsafe.As<T, byte>(ref source),
+                elementCount * (nuint)sizeof(T));
         }
 
-        // Non-inlinable wrapper around the loop for copying large blocks in chunks
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        private static void BulkMoveWithWriteBarrierBatch(ref byte destination, ref byte source, nuint byteCount)
+        /// <summary>
+        /// Copies elements from source to destination with ulong element count.
+        /// For unmanaged types only - does not handle reference types.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static unsafe void Memmove<T>(ref T destination, ref T source, ulong elementCount) where T : unmanaged
         {
-            Debug.Assert(byteCount > BulkMoveWithWriteBarrierChunk);
-
-            if (Unsafe.AreSame(ref source, ref destination))
-                return;
-
-            // This is equivalent to: (destination - source) >= byteCount || (destination - source) < 0
-            if ((nuint)(nint)Unsafe.ByteOffset(ref source, ref destination) >= byteCount)
-            {
-                // Copy forwards
-                do
-                {
-                    byteCount -= BulkMoveWithWriteBarrierChunk;
-                    BulkMoveWithWriteBarrierInternal(ref destination, ref source, BulkMoveWithWriteBarrierChunk);
-                    Thread.FastPollGC();
-                    destination = ref Unsafe.AddByteOffset(ref destination, BulkMoveWithWriteBarrierChunk);
-                    source = ref Unsafe.AddByteOffset(ref source, BulkMoveWithWriteBarrierChunk);
-                }
-                while (byteCount > BulkMoveWithWriteBarrierChunk);
-            }
-            else
-            {
-                // Copy backwards
-                do
-                {
-                    byteCount -= BulkMoveWithWriteBarrierChunk;
-                    BulkMoveWithWriteBarrierInternal(ref Unsafe.AddByteOffset(ref destination, byteCount), ref Unsafe.AddByteOffset(ref source, byteCount), BulkMoveWithWriteBarrierChunk);
-                    Thread.FastPollGC();
-                }
-                while (byteCount > BulkMoveWithWriteBarrierChunk);
-            }
-            BulkMoveWithWriteBarrierInternal(ref destination, ref source, byteCount);
-            Thread.FastPollGC();
+            UnmanagedSpanHelpers.Memmove(
+                ref Unsafe.As<T, byte>(ref destination),
+                ref Unsafe.As<T, byte>(ref source),
+                checked((nuint)(elementCount * (ulong)sizeof(T))));
         }
-
-#endif // !MONO
     }
 }