feat(int64): add UnmanagedSpan overloads and fix SimdMatMul

**SimdMatMul.cs**
- Replaced slow scalar fallback for large arrays with UnmanagedSpan.Clear()
- Before: for loop clearing one element at a time when outputSize > int.MaxValue
- After: vectorized UnmanagedSpan.Clear() for all sizes

**IArraySlice.cs**
- Added: `void CopyTo<T>(UnmanagedSpan<T> destination) where T : unmanaged`

**ArraySlice<T>.cs**
- Added: constructor `ArraySlice(UnmanagedMemoryBlock<T>, UnmanagedSpan<T>)`
- Added: `bool TryCopyTo(UnmanagedSpan<T> destination)`
- Added: `void CopyTo(UnmanagedSpan<T> destination)`
- Added: `void CopyTo(UnmanagedSpan<T> destination, long sourceOffset)`
- Added: `void CopyTo(UnmanagedSpan<T> destination, long sourceOffset, long sourceLength)`
- Added: explicit interface `IArraySlice.CopyTo<T1>(UnmanagedSpan<T1> destination)`

All overloads support long indexing for arrays exceeding int.MaxValue elements.

Author: Nucs

src/NumSharp.Core/Backends/Kernels/SimdMatMul.cs

@@ -3,6 +3,7 @@
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
+using NumSharp.Utilities;
 
 namespace NumSharp.Backends.Kernels
 {
@@ -42,16 +43,8 @@ public static class SimdMatMul
         public static unsafe void MatMulFloat(float* A, float* B, float* C, long M, long N, long K)
         {
 
-            // Zero output
-            long outputSize = M * N;
-            if (outputSize <= int.MaxValue)
-                new Span<float>(C, (int)outputSize).Clear();
-            else
-            {
-                // Clear in chunks for very large outputs
-                for (long i = 0; i < outputSize; i++)
-                    C[i] = 0f;
-            }
+            // Zero output using UnmanagedSpan for long indexing support
+            new UnmanagedSpan<float>(C, M * N).Clear();
 
             // Small matrices: use simple IKJ loop (blocking overhead not worth it)
             if (M <= BLOCKING_THRESHOLD && N <= BLOCKING_THRESHOLD && K <= BLOCKING_THRESHOLD)

src/NumSharp.Core/Backends/Unmanaged/ArraySlice`1.cs

@@ -64,6 +64,18 @@ public ArraySlice(UnmanagedMemoryBlock<T> memoryBlock, Span<T> slice)
             VoidAddress = Address = (T*)Unsafe.AsPointer(ref slice.GetPinnableReference());
         }
 
+        /// <summary>
+        ///     Creates a sliced <see cref="ArraySlice{T}"/> from an UnmanagedSpan.
+        ///     Supports long indexing for arrays &gt; 2B elements.
+        /// </summary>
+        public ArraySlice(UnmanagedMemoryBlock<T> memoryBlock, UnmanagedSpan<T> slice)
+        {
+            MemoryBlock = memoryBlock;
+            IsSlice = true;
+            Count = slice.Length;
+            VoidAddress = Address = (T*)Unsafe.AsPointer(ref slice.GetPinnableReference());
+        }
+
         /// <summary>
         ///     Creates a sliced <see cref="ArraySlice{T}"/>.
         /// </summary>
@@ -313,6 +325,69 @@ public void CopyTo(Span<T> destination, long sourceOffset, long sourceLength)
             CopyTo(destination, sourceOffset, sourceLength);
         }
 
+        /// <summary>
+        /// Tries to copy this slice's contents to an UnmanagedSpan destination.
+        /// Supports long indexing for arrays &gt; 2B elements.
+        /// </summary>
+        /// <param name="destination">The destination span.</param>
+        /// <returns>True if the copy succeeded, false if destination is too short.</returns>
+        public bool TryCopyTo(UnmanagedSpan<T> destination)
+        {
+            if ((ulong)Count > (ulong)destination.Length)
+                return false;
+
+            Buffer.MemoryCopy(Unsafe.AsPointer(ref destination.GetPinnableReference()), Address, destination.Length * ItemLength, Count * ItemLength);
+            return true;
+        }
+
+        /// <summary>
+        /// Copies this slice's contents to an UnmanagedSpan destination.
+        /// Supports long indexing for arrays &gt; 2B elements.
+        /// </summary>
+        /// <param name="destination">The destination span.</param>
+        [MethodImpl(OptimizeAndInline)]
+        public void CopyTo(UnmanagedSpan<T> destination)
+        {
+            if ((ulong)Count <= (ulong)destination.Length)
+            {
+                Buffer.MemoryCopy(Unsafe.AsPointer(ref destination.GetPinnableReference()), Address, destination.Length * ItemLength, Count * ItemLength);
+            }
+            else
+            {
+                throw new ArgumentException("Destination was too short.");
+            }
+        }
+
+        /// <summary>
+        /// Copies a portion of this slice to an UnmanagedSpan destination.
+        /// Supports long indexing for arrays &gt; 2B elements.
+        /// </summary>
+        /// <param name="destination">The destination span.</param>
+        /// <param name="sourceOffset">Offset in source (element count, not bytes).</param>
+        [MethodImpl(OptimizeAndInline)]
+        public void CopyTo(UnmanagedSpan<T> destination, long sourceOffset)
+        {
+            CopyTo(destination, sourceOffset, Count - sourceOffset);
+        }
+
+        /// <summary>
+        /// Copies a portion of this slice to an UnmanagedSpan destination.
+        /// Supports long indexing for arrays &gt; 2B elements.
+        /// </summary>
+        /// <param name="destination">The destination span.</param>
+        /// <param name="sourceOffset">Offset in source (element count, not bytes).</param>
+        /// <param name="sourceLength">Number of elements to copy.</param>
+        [MethodImpl(OptimizeAndInline)]
+        public void CopyTo(UnmanagedSpan<T> destination, long sourceOffset, long sourceLength)
+        {
+            if ((ulong)sourceOffset > (ulong)Count || (ulong)sourceLength > (ulong)(Count - sourceOffset))
+                throw new ArgumentOutOfRangeException();
+            if ((ulong)sourceLength > (ulong)destination.Length)
+                throw new ArgumentException("Destination was too short.");
+
+            Buffer.MemoryCopy(Unsafe.AsPointer(ref destination.GetPinnableReference()), Address + sourceOffset, destination.Length * ItemLength, sourceLength * ItemLength);
+        }
+
         [EditorBrowsable(EditorBrowsableState.Never)]
         [MethodImpl(Inline)]
         public ref T GetPinnableReference() => ref Unsafe.AsRef<T>(Address);
@@ -387,6 +462,18 @@ void IArraySlice.CopyTo<T1>(Span<T1> destination)
             this.CopyTo(Unsafe.AsPointer(ref destination.GetPinnableReference()));
         }
 
+        /// <summary>
+        /// Copies this slice's contents to an UnmanagedSpan destination.
+        /// Supports long indexing for arrays &gt; 2B elements.
+        /// </summary>
+        /// <param name="destination"></param>
+        void IArraySlice.CopyTo<T1>(UnmanagedSpan<T1> destination)
+        {
+            if ((ulong)Count > (ulong)destination.Length)
+                throw new ArgumentException("Destination was too short.");
+            Buffer.MemoryCopy(Unsafe.AsPointer(ref destination.GetPinnableReference()), VoidAddress, destination.Length * InfoOf<T1>.Size, Count * ItemLength);
+        }
+
         /// <summary>
         ///     Gets pinnable reference of the first item in the memory block storage.
         /// </summary>

src/NumSharp.Core/Backends/Unmanaged/Interfaces/IArraySlice.cs

@@ -52,6 +52,13 @@ public interface IArraySlice : IMemoryBlock, ICloneable, IEnumerable
         /// <param name="destination"></param>
         void CopyTo<T>(Span<T> destination);
 
+        /// <summary>
+        /// Copies this slice's contents to an UnmanagedSpan destination.
+        /// Supports long indexing for arrays &gt; 2B elements.
+        /// </summary>
+        /// <param name="destination"></param>
+        void CopyTo<T>(UnmanagedSpan<T> destination) where T : unmanaged;
+
         /// <summary>
         ///     Gets pinnable reference of the first item in the memory block storage.
         /// </summary>