fix: int64 indexing migration batch 5 - BUILD PASSING

Complete migration of int32 to int64 for indices, sizes, strides, offsets
across 16 files. Build now compiles successfully.

Core changes:
- Shape.Broadcasting.cs: All dimension/stride arrays now long[]
- NDArray.cs: Added long size constructor overloads
- TensorEngine/np.nonzero: Return NDArray<long>[] for index arrays
- ILKernelGenerator.Reduction.Axis.Simd: AxisReductionKernel delegate
  now uses long* for strides/shapes and long for sizes
- np.size: Return type changed to long
- np.array: Stride variables changed to long for pointer arithmetic
- NDArray.Indexing.Masking: Shape arrays and counts now long

Random functions:
- np.random.choice/shuffle: Added overflow checks for int.MaxValue limit
  (Random.Next only supports int; full long support deferred)

Build infrastructure:
- NumSharp.Core.csproj: Exclude *.template.cs and *.regen_disabled files

Test status: 193 failures due to memory corruption - needs investigation
in stride/offset calculations.

Author: Nucs

docs/INT64_MIGRATION_PROGRESS.md

@@ -11,7 +11,7 @@ public partial class np
         /// <param name="axis">Axis along which the elements are counted. By default, give the total number of elements.</param>
         /// <returns>Number of elements along the specified axis.</returns>
         /// <remarks>https://numpy.org/doc/stable/reference/generated/numpy.ma.size.html</remarks>
-        public static int size(NDArray a, int? axis = null)
+        public static long size(NDArray a, int? axis = null)
         {
             if (a == null)
                 throw new ArgumentNullException(nameof(a));

src/NumSharp.Core/APIs/np.size.cs

@@ -92,7 +92,11 @@ public override NDArray SwapAxes(NDArray nd, int axis1, int axis2)
             dims[axis1] = axis2;
             dims[axis2] = axis1;
 
-            return Transpose(nd, dims);
+            // Convert long[] to int[] for Transpose (axes are limited to int range)
+            var intDims = new int[ndims];
+            for (int i = 0; i < ndims; i++)
+                intDims[i] = (int)dims[i];
+            return Transpose(nd, intDims);
         }
 
         public override NDArray RollAxis(NDArray nd, int axis, int start = 0)
@@ -157,7 +161,7 @@ public override NDArray Transpose(NDArray nd, int[] premute = null)
             // Handle empty arrays: just create a new array with permuted dimensions, no data copy needed
             if (nd.Shape.size == 0)
             {
-                var emptyDims = new int[n];
+                var emptyDims = new long[n];
                 for (i = 0; i < n; i++)
                     emptyDims[i] = nd.Shape.dimensions[permutation[i]];
                 return new NDArray(nd.dtype, emptyDims);
@@ -175,8 +179,8 @@ public override NDArray Transpose(NDArray nd, int[] premute = null)
             var srcStrides = shape.strides;
 
             // Permute dimensions and strides
-            var permutedDims = new int[n];
-            var permutedStrides = new int[n];
+            var permutedDims = new long[n];
+            var permutedStrides = new long[n];
             for (i = 0; i < n; i++)
             {
                 permutedDims[i] = srcDims[permutation[i]];
@@ -185,7 +189,7 @@ public override NDArray Transpose(NDArray nd, int[] premute = null)
 
             // Create the transposed shape via constructor (immutable)
             // IsContiguous is computed from strides and will be false for transposed arrays
-            int bufSize = shape.bufferSize > 0 ? shape.bufferSize : shape.size;
+            long bufSize = shape.bufferSize > 0 ? shape.bufferSize : shape.size;
             var newShape = new Shape(permutedDims, permutedStrides, shape.offset, bufSize);
 
             // Return an alias (view) with the permuted shape

src/NumSharp.Core/Backends/Default/ArrayManipulation/Default.Transpose.cs

@@ -19,8 +19,8 @@ public partial class DefaultEngine
         /// - Handles contiguous and strided arrays efficiently
         /// </remarks>
         /// <param name="nd">Input array</param>
-        /// <returns>Array of NDArray&lt;int&gt;, one per dimension containing indices of non-zero elements</returns>
-        public override NDArray<int>[] NonZero(NDArray nd)
+        /// <returns>Array of NDArray&lt;long&gt;, one per dimension containing indices of non-zero elements</returns>
+        public override NDArray<long>[] NonZero(NDArray nd)
         {
             // Type dispatch to generic implementation
             switch (nd.typecode)
@@ -44,9 +44,9 @@ public override NDArray<int>[] NonZero(NDArray nd)
 
         /// <summary>
         /// Generic implementation of nonzero using ILKernelGenerator.
-        /// Both contiguous and strided paths now use the unified IL-based approach.
+        /// Uses coordinate-based iteration via ILKernelGenerator for all cases.
         /// </summary>
-        private static unsafe NDArray<int>[] nonzeros<T>(NDArray<T> x) where T : unmanaged
+        private static unsafe NDArray<long>[] nonzeros<T>(NDArray<T> x) where T : unmanaged
         {
             // Ensure at least 1D (NumPy behavior)
             x = np.atleast_1d(x).MakeGeneric<T>();
@@ -58,22 +58,14 @@ private static unsafe NDArray<int>[] nonzeros<T>(NDArray<T> x) where T : unmanag
             // NumPy: np.nonzero(np.array([])) -> (array([], dtype=int64),)
             if (size == 0)
             {
-                var emptyResult = new NDArray<int>[ndim];
+                var emptyResult = new NDArray<long>[ndim];
                 for (int i = 0; i < ndim; i++)
-                    emptyResult[i] = new NDArray<int>(0);
+                    emptyResult[i] = new NDArray<long>(0);
                 return emptyResult;
             }
 
-            // SIMD fast path for contiguous arrays
-            if (shape.IsContiguous && ILKernelGenerator.Enabled && ILKernelGenerator.VectorBits > 0)
-            {
-                var flatIndices = new ArraySlice<long>(Math.Max(16L, size / 4L));
-                kp.FindNonZero((T*)x.Address, size, flatIndices);
-                return kp.ConvertFlatToCoordinates(flatIndices, x.shape);
-            }
-
-            // Strided path for non-contiguous arrays (transposed, sliced, etc.)
-            // Uses coordinate-based iteration via ILKernelGenerator
+            // Use strided helper for all cases (handles both contiguous and non-contiguous)
+            // The ILKernelGenerator.FindNonZeroStridedHelper uses coordinate-based iteration
             return ILKernelGenerator.FindNonZeroStridedHelper((T*)x.Address, shape.dimensions, shape.strides, shape.offset);
         }
 

src/NumSharp.Core/Backends/Default/Indexing/Default.NonZero.cs

@@ -29,8 +29,8 @@ public static partial class ILKernelGenerator
         private static unsafe AxisReductionKernel CreateAxisReductionKernelTyped<T>(AxisReductionKernelKey key)
             where T : unmanaged
         {
-            return (void* input, void* output, int* inputStrides, int* inputShape,
-                    int* outputStrides, int axis, int axisSize, int ndim, int outputSize) =>
+            return (void* input, void* output, long* inputStrides, long* inputShape,
+                    long* outputStrides, int axis, long axisSize, int ndim, long outputSize) =>
             {
                 AxisReductionSimdHelper<T>(
                     (T*)input, (T*)output,
@@ -57,12 +57,12 @@ private static unsafe AxisReductionKernel CreateAxisReductionKernelTyped<T>(Axis
         /// <param name="op">Reduction operation</param>
         internal static unsafe void AxisReductionSimdHelper<T>(
             T* input, T* output,
-            int* inputStrides, int* inputShape, int* outputStrides,
-            int axis, int axisSize, int ndim, int outputSize,
+            long* inputStrides, long* inputShape, long* outputStrides,
+            int axis, long axisSize, int ndim, long outputSize,
             ReductionOp op)
             where T : unmanaged
         {
-            int axisStride = inputStrides[axis];
+            long axisStride = inputStrides[axis];
 
             // Check if the reduction axis is contiguous (stride == 1)
             bool axisContiguous = axisStride == 1;
@@ -89,19 +89,19 @@ internal static unsafe void AxisReductionSimdHelper<T>(
             bool isMean = op == ReductionOp.Mean;
 
             // Sequential loop over output elements
-            for (int outIdx = 0; outIdx < outputSize; outIdx++)
+            for (long outIdx = 0; outIdx < outputSize; outIdx++)
             {
                 // Convert linear output index to coordinates and compute input base offset
-                int remaining = outIdx;
-                int inputBaseOffset = 0;
-                int outputOffset = 0;
+                long remaining = outIdx;
+                long inputBaseOffset = 0;
+                long outputOffset = 0;
 
                 for (int d = 0; d < outputNdim; d++)
                 {
                     // Map output dimension d to input dimension
                     int inputDim = d >= axis ? d + 1 : d;
 
-                    int coord = remaining / outputDimStridesArray[d];
+                    long coord = remaining / outputDimStridesArray[d];
                     remaining = remaining % outputDimStridesArray[d];
 
                     inputBaseOffset += coord * inputStrides[inputDim];
@@ -149,7 +149,7 @@ private static T DivideByCountTyped<T>(T value, long count) where T : unmanaged
             if (typeof(T) == typeof(int))
             {
                 // Integer division
-                int result = (int)(object)value / count;
+                int result = (int)((int)(object)value / count);
                 return (T)(object)result;
             }
             if (typeof(T) == typeof(long))

src/NumSharp.Core/Backends/Kernels/ILKernelGenerator.Reduction.Axis.Simd.cs

@@ -263,6 +263,23 @@ public NDArray(NPTypeCode dtype, int size) : this(dtype, Shape.Vector(size), tru
         /// <remarks>This constructor calls <see cref="IStorage.Allocate(NumSharp.Shape,System.Type)"/></remarks>
         public NDArray(NPTypeCode dtype, int size, bool fillZeros) : this(dtype, Shape.Vector(size), true) { }
 
+        /// <summary>
+        ///     Constructor which initialize elements with length of <paramref name="size"/>
+        /// </summary>
+        /// <param name="dtype">Internal data type</param>
+        /// <param name="size">The size as a single dimension shape (long for large arrays)</param>
+        /// <remarks>This constructor calls <see cref="IStorage.Allocate(NumSharp.Shape,System.Type)"/></remarks>
+        public NDArray(NPTypeCode dtype, long size) : this(dtype, Shape.Vector(size), true) { }
+
+        /// <summary>
+        ///     Constructor which initialize elements with length of <paramref name="size"/>
+        /// </summary>
+        /// <param name="dtype">Internal data type</param>
+        /// <param name="size">The size as a single dimension shape (long for large arrays)</param>
+        /// <param name="fillZeros">Should set the values of the new allocation to default(dtype)? otherwise - old memory noise</param>
+        /// <remarks>This constructor calls <see cref="IStorage.Allocate(NumSharp.Shape,System.Type)"/></remarks>
+        public NDArray(NPTypeCode dtype, long size, bool fillZeros) : this(dtype, Shape.Vector(size), fillZeros) { }
+
         /// <summary>
         /// Constructor which initialize elements with 0
         /// type and shape are given.

src/NumSharp.Core/Backends/NDArray.cs

@@ -212,7 +212,7 @@ public abstract class TensorEngine
 
         #region Indexing
 
-        public abstract NDArray<int>[] NonZero(NDArray a);
+        public abstract NDArray<long>[] NonZero(NDArray a);
 
         public abstract long CountNonZero(NDArray a);
 

src/NumSharp.Core/Backends/TensorEngine.cs

@@ -60,7 +60,7 @@ public static bool are_broadcastable(NDArray lhs, NDArray rhs)
         /// <remarks>https://docs.scipy.org/doc/numpy/reference/generated/numpy.broadcast_arrays.html</remarks>
         public static bool are_broadcastable(long[] shape1, long[] shape2)
         {
-            return DefaultEngine.AreBroadcastable(new[] { new Shape(shape1), new Shape(shape2) });
+            return Shape.AreBroadcastable(new Shape(shape1), new Shape(shape2));
         }
     }
 }

src/NumSharp.Core/Creation/np.are_broadcastable.cs

@@ -170,7 +170,7 @@ public static NDArray array<T>(T[][] data) where T : unmanaged
                 NDArray @out = new NDArray(InfoOf<T>.NPTypeCode, new Shape(len1, len2));
 
                 var strides = @out.strides;
-                int stride1 = strides[0];
+                long stride1 = strides[0];
                 Debug.Assert(strides[1] == 1);
 
                 T* addr = (T*)@out.Address;
@@ -209,8 +209,8 @@ public static NDArray array<T>(T[][][] data) where T : unmanaged
                 NDArray @out = new NDArray(InfoOf<T>.NPTypeCode, new Shape(len1, len2, len3));
 
                 var strides = @out.strides;
-                int stride1 = strides[0];
-                int stride2 = strides[1];
+                long stride1 = strides[0];
+                long stride2 = strides[1];
                 Debug.Assert(strides[2] == 1);
 
                 T* addr = (T*)@out.Address;
@@ -255,9 +255,9 @@ public static NDArray array<T>(T[][][][] data) where T : unmanaged
                 NDArray @out = new NDArray(InfoOf<T>.NPTypeCode, new Shape(len1, len2, len3, len4));
 
                 var strides = @out.strides;
-                int stride1 = strides[0];
-                int stride2 = strides[1];
-                int stride3 = strides[2];
+                long stride1 = strides[0];
+                long stride2 = strides[1];
+                long stride3 = strides[2];
                 Debug.Assert(strides[3] == 1);
 
                 T* addr = (T*)@out.Address;
@@ -308,10 +308,10 @@ public static NDArray array<T>(T[][][][][] data) where T : unmanaged
                 NDArray @out = new NDArray(InfoOf<T>.NPTypeCode, new Shape(len1, len2, len3, len4, len5));
 
                 var strides = @out.strides;
-                int stride1 = strides[0];
-                int stride2 = strides[1];
-                int stride3 = strides[2];
-                int stride4 = strides[3];
+                long stride1 = strides[0];
+                long stride2 = strides[1];
+                long stride3 = strides[2];
+                long stride4 = strides[3];
                 Debug.Assert(strides[4] == 1);
 
                 T* addr = (T*)@out.Address;

src/NumSharp.Core/Creation/np.array.cs

@@ -20,7 +20,7 @@ public static partial class np
         /// <param name="a">Input array.</param>
         /// <returns>Indices of elements that are non-zero.</returns>
         /// <remarks>https://numpy.org/doc/stable/reference/generated/numpy.nonzero.html</remarks>
-        public static NDArray<int>[] nonzero(NDArray a)
+        public static NDArray<long>[] nonzero(NDArray a)
             => a.TensorEngine.NonZero(a);
     }
 }