[Major Rewrite] Index/nd.size/nd.shape int→long#596
Open
Conversation
Nucs
changed the title
Nucs
changed the title
Nucs
changed the title
Extended the keepdims fix to all remaining reduction operations: - ReduceAMax (np.amax, np.max) - ReduceAMin (np.amin, np.min) - ReduceProduct (np.prod) - ReduceStd (np.std) - ReduceVar (np.var) Also fixed np.amax/np.amin API layer which ignored keepdims when axis=null. Added comprehensive parameterized test covering all reductions with multiple dtypes (Int32, Int64, Single, Double, Int16, Byte) to prevent regression. All 7 reduction functions now correctly preserve dimensions with keepdims=true, matching NumPy 2.x behavior.
Apply .gitattributes normalization across all text files. No code changes - only CRLF → LF conversion. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
…N handling This commit adds comprehensive SIMD acceleration for reduction operations and fixes several NumPy compatibility issues. - AllSimdHelper<T>(): SIMD-accelerated boolean all() with early-exit on first zero - AnySimdHelper<T>(): SIMD-accelerated boolean any() with early-exit on first non-zero - ArgMaxSimdHelper<T>(): Two-pass SIMD: find max value, then find index - ArgMinSimdHelper<T>(): Two-pass SIMD: find min value, then find index - NonZeroSimdHelper<T>(): Collects indices where elements != 0 - CountTrueSimdHelper(): Counts true values in bool array - CopyMaskedElementsHelper<T>(): Copies elements where mask is true - ConvertFlatIndicesToCoordinates(): Converts flat indices to per-dimension arrays - **np.any axis-based reduction**: Fixed inverted logic in ComputeAnyPerAxis<T>. Was checking `Equals(default)` (returning true when zero found) instead of `!Equals(default)` (returning true when non-zero found). Also fixed return value to indicate computation success. - **ArgMax/ArgMin NaN handling**: Added NumPy-compatible NaN propagation where first NaN always wins. For both argmax and argmin, NaN takes precedence over any other value including Infinity. - **ArgMax/ArgMin empty array**: Now throws ArgumentException on empty arrays matching NumPy's ValueError behavior. - **ArgMax/ArgMin Boolean support**: Added Boolean type handling. For argmax, finds first True; for argmin, finds first False. - np.all(): Now uses AllSimdHelper for linear (axis=None) reduction - np.any(): Now uses AnySimdHelper for linear reduction - np.nonzero(): Added SIMD fast path for contiguous arrays - Boolean masking (arr[mask]): Added SIMD fast path using CountTrueSimdHelper and CopyMaskedElementsHelper Added comprehensive ownership/responsibility documentation to all ILKernelGenerator partial class files explaining the architecture: - ILKernelGenerator.cs: Core infrastructure and type mapping - ILKernelGenerator.Binary.cs: Same-type binary operations - ILKernelGenerator.MixedType.cs: Mixed-type with promotion - ILKernelGenerator.Unary.cs: Unary element-wise operations - ILKernelGenerator.Comparison.cs: Comparison operations - ILKernelGenerator.Reduction.cs: Reductions and SIMD helpers Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
…ions
Implements all missing kernel operations and routes SIMD helpers through
IKernelProvider interface for future backend abstraction.
- Power: IL kernel with Math.Pow scalar operation
- FloorDivide: np.floor_divide with NumPy floor-toward-negative-infinity semantics
- LeftShift/RightShift: np.left_shift, np.right_shift with SIMD Vector.ShiftLeft/Right
- Truncate: Vector.Truncate SIMD support
- Reciprocal: np.reciprocal (1/x) with SIMD
- Square: np.square optimized (x*x instead of power(x,2))
- Cbrt: np.cbrt cube root
- Deg2Rad/Rad2Deg: np.deg2rad, np.rad2deg (np.radians/np.degrees aliases)
- BitwiseNot: np.invert, np.bitwise_not with Vector.OnesComplement
- Var/Std: SIMD two-pass algorithm with interface integration
- NanSum/NanProd: np.nansum, np.nanprod (ignore NaN values)
- NanMin/NanMax: np.nanmin, np.nanmax (ignore NaN values)
- Route 6 SIMD helpers through IKernelProvider interface:
- All<T>, Any<T>, FindNonZero<T>, ConvertFlatToCoordinates
- CountTrue, CopyMasked<T>
- Clip kernel: SIMD Vector.Min/Max (~620→350 lines)
- Modf kernel: SIMD Vector.Truncate (.NET 9+)
- ATan2: Fixed wrong pointer type (byte*) for x operand in all non-byte cases
- ILKernelGenerator.Clip.cs, ILKernelGenerator.Modf.cs
- Default.{Cbrt,Deg2Rad,FloorDivide,Invert,Rad2Deg,Reciprocal,Shift,Square,Truncate}.cs
- np.{cbrt,deg2rad,floor_divide,invert,left_shift,nanprod,nansum,rad2deg,reciprocal,right_shift,trunc}.cs
- np.{nanmax,nanmin}.cs
- ShiftOpTests.cs, BinaryOpTests.cs (ATan2 tests)
This commit concludes a comprehensive audit of all np.* and DefaultEngine operations against NumPy 2.x specifications. - **ATan2**: Fixed non-contiguous array handling by adding np.broadcast_arrays() and .copy() materialization before pointer-based processing - **NegateBoolean**: Removed buggy linear-indexing path, now routes through ExecuteUnaryOp with new UnaryOp.LogicalNot for proper stride handling - **np.square(int)**: Now preserves integer dtype instead of promoting to double - **np.invert(bool)**: Now uses logical NOT (!x) instead of bitwise NOT (~x) - **np.power(NDArray, NDArray)**: Added array-to-array power overloads - **np.logical_and/or/not/xor**: New functions in Logic/np.logical.cs - **np.equal/not_equal/less/greater/less_equal/greater_equal**: 18 new comparison functions in Logic/np.comparison.cs - **argmax/argmin keepdims**: Added keepdims parameter matching NumPy API - Renamed `outType` parameter to `dtype` in 19 np.*.cs files to match NumPy - Added UnaryOp.LogicalNot to KernelOp.cs for boolean array negation - Created docs/KERNEL_API_AUDIT.md tracking Definition of Done criteria - Updated .claude/CLAUDE.md with DOD section and current status - Added NonContiguousTests.cs with 35+ tests for strided/broadcast arrays - Added DtypeCoverageTests.cs with 26 parameterized tests for all 12 dtypes - Added np.comparison.Test.cs for new comparison functions - Updated KernelMisalignmentTests.cs to verify fixed behaviors Files: 43 changed, 5 new files added Tests: 3058 passed (93% of 3283 total) Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Bug #126 - Empty array comparison returns scalar (FIXED): - All 6 comparison operators now return empty boolean arrays - Files: NDArray.Equals.cs, NotEquals.cs, Greater.cs, Lower.cs Bug #127 - Single-element axis reduction shares memory (FIXED): - Changed Storage.Alias() and squeeze_fast() to return copies - Fixed 8 files: Add, AMax, AMin, Product, Mean, Var, Std, CumAdd - Added 20 memory isolation tests Bug #128 - Empty array axis reduction returns scalar (FIXED): - Proper empty array handling for all 9 reduction operations - Sum→zeros, Prod→ones, Min/Max→ValueError, Mean/Std/Var→NaN - Added 22 tests matching NumPy behavior Bug #130 - np.unique NaN sorts to beginning (FIXED): - Added NaNAwareDoubleComparer and NaNAwareSingleComparer - NaN now sorts to end (NaN > any non-NaN value) - Matches NumPy: [-inf, 1, 2, inf, nan] Test summary: +54 new tests, all passing Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Replace 20K-line Regen template with clean 300-line implementation: - ILKernelGenerator.MatMul.cs: Cache-blocked SIMD kernels for float/double - 64x64 tile blocking for L1/L2 cache optimization - Vector256 with FMA (Fused Multiply-Add) when available - IKJ loop order for sequential memory access on B matrix - Parallel execution for matrices > 65K elements - Default.MatMul.2D2D.cs: Clean dispatcher with fallback - SIMD fast path for contiguous same-type float/double - Type-specific pointer loops for int/long - Generic double-accumulator fallback for mixed types | Size | Float32 | Float64 | |---------|---------|---------| | 32x32 | 34x | 18x | | 64x64 | 38x | 29x | | 128x128 | 15x | 58x | | 256x256 | 183x | 119x | - Before: 19,862 lines (Regen templates, 1728 type combinations) - After: 284 lines (clean, maintainable) Old Regen template preserved as .regen_disabled for reference. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
IL Kernel Infrastructure: - Add ILKernelGenerator.Scan.cs for CumSum scan kernels with SIMD V128/V256/V512 paths - Extend ILKernelGenerator.Reduction.cs with Var/Std/ArgMax/ArgMin axis reduction support - Extend ILKernelGenerator.Clip.cs with strided/broadcast array helpers - Extend ILKernelGenerator.Modf.cs with special value handling (NaN, Inf, -0) - Add IKernelProvider interface extensions for new kernel types DefaultEngine Migrations: - Default.Reduction.Var.cs: IL fast path for contiguous arrays, single-element fix - Default.Reduction.Std.cs: IL fast path for contiguous arrays, single-element fix - Default.Reduction.CumAdd.cs: IL scan kernel integration - Default.Reduction.ArgMax.cs: IL axis reduction with proper coordinate tracking - Default.Reduction.ArgMin.cs: IL axis reduction with proper coordinate tracking - Default.Power.cs: Scalar exponent path migrated to IL kernels - Default.Clip.cs: Unified IL path (76% code reduction, 914→240 lines) - Default.NonZero.cs: Strided IL fallback path - Default.Modf.cs: Unified IL with special float handling Bug Fixes: - np.var.cs / np.std.cs: ddof parameter now properly passed through - Var/Std single-element arrays now return double (matching NumPy) Tests (3,500+ lines added): - ArgMaxArgMinComprehensiveTests.cs: 480 lines covering all dtypes, shapes, axes - VarStdComprehensiveTests.cs: 462 lines covering ddof, empty arrays, edge cases - CumSumComprehensiveTests.cs: 381 lines covering accumulation, overflow, dtypes - np_nonzero_strided_tests.cs: 221 lines for strided/transposed array support - 7 NumPyPortedTests files: Edge cases from NumPy test suite Code Impact: - Net reduction: 543 lines removed (6,532 added - 2,172 removed from templates) - ReductionTests.cs removed (884 lines) - replaced by comprehensive per-operation tests - Eliminated ~1MB of switch/case template code via IL generation Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
… ClipEdgeCaseTests - Fix BeOfValues params array unpacking: Cast GetData<T>() to object[] for proper params expansion - Mark Power_Integer_LargeValues as Misaligned: Math.Pow precision loss for large integers is expected - Fix np.full argument order in Clip tests: NumSharp uses (fill_value, shapes) not NumPy's (shape, fill_value) - Mark Base_ReductionKeepdims_Size1Axis_ReturnsView as OpenBugs: view optimization not implemented Test results: 3,879 total, 3,868 passed, 11 skipped, 0 failed
Breaking change: Migrate from int32 to int64 for array indexing. Core type changes: - Shape: size, dimensions[], strides[], offset, bufferSize -> long - Slice: Start, Stop, Step -> long - SliceDef: Start, Step, Count -> long - NDArray: shape, size, strides properties -> long/long[] Helper methods: - Shape.ComputeLongShape() for int[] -> long[] conversion - Shape.Vector(long) overload Related to #584
- NDArray constructors: int size -> long size - NDArray.GetAtIndex/SetAtIndex: int index -> long index - UnmanagedStorage.GetAtIndex/SetAtIndex: int index -> long index - ValueCoordinatesIncrementor.Next(): int[] -> long[] - DefaultEngine.MoveAxis: int[] -> long[] Build still failing - cascading changes needed in: - All incrementors (NDCoordinatesIncrementor, NDOffsetIncrementor, etc.) - NDIterator and all cast files - UnmanagedStorage.Cloning - np.random.shuffle, np.random.choice Related to #584
- this[long index] indexer - GetIndex/SetIndex with long index - Slice(long start), Slice(long start, long length) - Explicit IArraySlice implementations Build has 439 cascading errors remaining across 50+ files. Most are straightforward loop index changes (int → long). Related to #584
…int[] convenience Pattern applied: - Get*(params long[] indices) - primary implementation calling Storage - Get*(params int[] indices) - delegates to long[] via Shape.ComputeLongShape() - Set*(value, params long[] indices) - primary implementation - Set*(value, params int[] indices) - delegates to long[] version Covers: GetData, GetBoolean, GetByte, GetChar, GetDecimal, GetDouble, GetInt16, GetInt32, GetInt64, GetSingle, GetUInt16, GetUInt32, GetUInt64, GetValue, GetValue<T>, SetData (3 overloads), SetValue (3 overloads), SetBoolean, SetByte, SetInt16, SetUInt16, SetInt32, SetUInt32, SetInt64, SetUInt64, SetChar, SetDouble, SetSingle, SetDecimal Related to #584
…check - Add overflow check when string length exceeds int.MaxValue - Explicitly cast Count to int with comment explaining .NET string limitation - Part of int32 to int64 indexing migration (#584)
- Add overflow check in AsString() instead of Debug.Assert - Implement empty SetString(string, int[]) wrapper to call long[] version - Change GetStringAt/SetStringAt offset parameter from int to long - Part of int32 to int64 indexing migration (#584)
…ndices - GetValue(int[]) -> GetValue(long[]) - GetValue<T>(int[]) -> GetValue<T>(long[]) - All direct getters (GetBoolean, GetByte, etc.) -> long[] indices - SetValue<T>(int[]) -> SetValue<T>(long[]) - SetValue(object, int[]) -> SetValue(object, long[]) - SetData(object/NDArray/IArraySlice, int[]) -> long[] indices - All typed setters (SetBoolean, SetByte, etc.) -> long[] indices - Fix int sliceSize -> long sliceSize in GetData Part of int32 to int64 indexing migration (#584)
- NDArray`1.cs: Add long[] indexer, int[] delegates to it - UnmanagedStorage.cs: Add Span overflow check (Span limited to int) - UnmanagedStorage.Cloning.cs: Add ArraySlice allocation overflow check - NDIterator.cs: Change size field from int to long Note: ~900 cascading errors remain from: - ArraySlice (needs long count) - Incrementors (need long coords) - Various Default.* operations - IKernelProvider interface Part of int32 to int64 indexing migration (#584)
- NDCoordinatesIncrementor: Next() returns long[], Index is long[] - NDCoordinatesIncrementorAutoResetting: all fields long - NDOffsetIncrementor: Next() returns long, index/offset are long - NDOffsetIncrementorAutoresetting: same changes - ValueOffsetIncrementor: Next() returns long - ValueOffsetIncrementorAutoresetting: same changes - NDCoordinatesAxisIncrementor: constructor takes long[] - NDCoordinatesLeftToAxisIncrementor: dimensions/Index are long[] - NDExtendedCoordinatesIncrementor: dimensions/Index are long[] Part of int64 indexing migration (#584)
- ArraySlice.cs: Change Allocate count parameter handling for long - UnmanagedMemoryBlock: Adjust for long count - np.random.choice.cs: Add explicit casts for int64 indices - np.random.shuffle.cs: Update index handling for long - ValueCoordinatesIncrementor.cs: Add long[] Index property - NDArray.cs: Remove duplicate/dead code (112 lines)
MatMul.2D2D.cs: - M, K, N parameters now long throughout - All method signatures updated (long M, long K, long N) - Loop counters changed to long - Coordinate arrays changed to long[] NDArray.unique.cs: - len variable changed to long - getOffset delegate now Func<long, long> - Loop counters changed to long NDArray.itemset.cs: - Parameters changed from int[] to long[] NdArray.Convolve.cs: - Explicit (int) casts for size - acceptable because convolution on huge arrays is computationally infeasible (O(n*m)) NDArray.matrix_power.cs: - Cast shape[0] to int for np.eye (pending np.eye long support) np.linalg.norm.cs: - Fixed bug: was casting int[] to long[] incorrectly Remaining work: - IL kernel interfaces still use int for count/size - SIMD helpers (SimdMatMul) expect int parameters - Default.Clip, Default.ATan2, Default.Transpose, Default.NonZero all need coordinated IL kernel + caller updates
….Unmanaged - IKernelProvider: Changed interface to use long for size/count parameters - Default.Transpose: Fixed int/long coordinate and stride handling - ILKernelGenerator.Clip: Updated to use long loop counters - TensorEngine: Updated method signatures for long indexing - UnmanagedStorage.Slicing: Fixed slice offset to use long - Shape.Unmanaged: Fixed unsafe pointer methods for long indices
- SimdMatMul.MatMulFloat accepts long M, N, K (validates <= int.MaxValue internally) - MatMul2DKernel delegate uses long M, N, K - np.nonzero returns NDArray<long>[] instead of NDArray<int>[] - NDArray pointer indexer changed from int* to long* - SwapAxes uses long[] for permutation
- AllSimdHelper<T> parameter: int totalSize → long totalSize - Loop counters and vectorEnd: int → long - Part of int64 indexing migration
ILKernelGenerator.Clip.cs: - All loop counters and vectorEnd variables changed from int to long - Scalar loops also changed to use long iterators Default.Dot.NDMD.cs: - contractDim, lshape, rshape, retShape → long/long[] - Method signatures updated for TryDotNDMDSimd, DotNDMDSimdFloat/Double - ComputeIterStrides, ComputeBaseOffset, ComputeRhsBaseOffset → long - DotProductFloat, DotProductDouble → long parameters - DotNDMDGeneric → long coordinates and iterators - DecomposeIndex, DecomposeRhsIndex → long parameters
… fixed statements ILKernelGenerator.Clip.cs: - Changed 'int offset = shape.TransformOffset' to 'long offset' Default.ATan2.cs: - Changed fixed (int* ...) to fixed (long* ...) for strides and dimensions - Updated ClassifyATan2Path signature to use long* - Updated ExecuteATan2Kernel fixed statements Note: StrideDetector and MixedTypeKernel delegate still need updating
- IsContiguous: int* strides/shape -> long* strides/shape - IsScalar: int* strides -> long* strides - CanSimdChunk: int* params -> long*, innerSize/lhsInner/rhsInner -> long - Classify: int* params -> long* - expectedStride local -> long
Comprehensive guide for developers continuing the migration: - Decision tree for when to use long vs int - 7 code patterns with before/after examples - Valid exceptions (Span, managed arrays, complexity limits) - What stays int (ndim, dimension indices, Slice) - Checklist for each file migration - Common error patterns and fixes - File priority categories - Quick reference table
Convert UnmanagedSpan<T> and ReadOnlyUnmanagedSpan<T> from int to long: Core changes in both types: - _length field: int → long - Length property: int → long - Indexer: this[int] → this[long] - Slice methods: (int start) → (long start), (int, int) → (long, long) - Pointer constructor: (void*, int) → (void*, long) - Internal constructor: (ref T, int) → (ref T, long) - Enumerator._index: int → long Bounds checking updated: - Changed (uint)x casts to (ulong)x for proper 64-bit comparisons - Removed /* force zero-extension */ casts that are no longer needed Array constructors retain int parameters since .NET arrays use int indices. This enables UnmanagedSpan to represent >2 billion element arrays, which is the core requirement for NumSharp's long indexing support.
File renames: - MemoryExtensions*.cs → UnmanagedSpanExtensions*.cs - Buffer.cs → UnmanagedBuffer.cs Class renames: - MemoryExtensions → UnmanagedSpanExtensions - Buffer → UnmanagedBuffer int → long conversions across all helper files: - Method parameters: length, searchSpaceLength, valueLength, start - Return types: IndexOf, LastIndexOf, Count, BinarySearch, etc. - Local variables: index, i, offset Files converted: - UnmanagedSpanHelpers.cs (base helpers - already used nuint) - UnmanagedSpanHelpers.T.cs (generic IndexOf, Contains, SequenceEqual) - UnmanagedSpanHelpers.Byte.cs (byte-optimized operations) - UnmanagedSpanHelpers.Char.cs (char-optimized operations) - UnmanagedSpanExtensions.cs (main extension methods) - UnmanagedBuffer.cs (Memmove - already used nuint) This enables all span operations to work with >2 billion elements.
Created UnmanagedSpanThrowHelper.cs with minimal exception helpers: - ThrowArgumentOutOfRangeException - ThrowArgumentNullException - ThrowArgumentException_DestinationTooShort - ThrowArrayTypeMismatchException - ThrowIndexOutOfRangeException - ThrowInvalidOperationException - ThrowArgument_TypeContainsReferences - SR string constants for error messages Deleted 30 files that duplicate .NET built-in functionality: - Unsafe.cs, RuntimeHelpers.cs (use System.Runtime.CompilerServices) - MemoryMarshal*.cs (use System.Runtime.InteropServices) - Index.cs, Range.cs (use System.Index, System.Range) - Vector*.cs, BitOperations.cs (use System.Runtime.Intrinsics) - Memory.cs, ReadOnlyMemory.cs (use System.Memory<T>) - *Pool.cs, *Manager.cs, *Handle.cs (buffer infrastructure) - *Sequence*.cs, *BufferWriter*.cs (not needed) - *Marshaller.cs, *Enumerator.cs (P/Invoke, text - not needed) - SearchValues.cs, Marvin.cs, NativeMemory.cs (not needed) - Attribute files, System.*.cs ref assemblies Remaining 17 files are the core UnmanagedSpan implementation.
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)
**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.
Implements Span<T>-equivalent extension methods for UnmanagedSpan<T> and ReadOnlyUnmanagedSpan<T> with full long indexing support. **Search Methods (return long)** - IndexOf(T value) - first occurrence - IndexOf(ReadOnlyUnmanagedSpan<T> value) - first sequence occurrence - LastIndexOf(T value) - last occurrence - LastIndexOf(ReadOnlyUnmanagedSpan<T> value) - last sequence occurrence - IndexOfAny(T, T) / IndexOfAny(T, T, T) / IndexOfAny(span) - LastIndexOfAny(T, T) / LastIndexOfAny(T, T, T) / LastIndexOfAny(span) - BinarySearch(T) / BinarySearch(T, IComparer<T>) **Predicates** - Contains(T value) - existence check - SequenceEqual(span) / SequenceEqual(span, comparer) - StartsWith(span) / EndsWith(span) **Sorting (IntroSort with long indices)** - Sort() / Sort(IComparer<T>) / Sort(Comparison<T>) - Sort(keys, items) - paired sort with values span **Modification** - Reverse() - in-place reversal - Replace(oldValue, newValue) - in-place replacement **Statistics** - Count(T value) - occurrence count (returns long) - CommonPrefixLength(span) - shared prefix length All methods support >2B element spans via long indexing.
Port .NET runtime SIMD implementations for UnmanagedSpan search operations: UnmanagedSpanHelpers.T.cs (new file): - Fill<T>: SIMD-accelerated fill for unmanaged types (Vector128/256/512) - ContainsValueType<T>: SIMD search with INumber<T> constraint - IndexOfValueType<T>: SIMD first-occurrence search - LastIndexOfValueType<T>: SIMD last-occurrence search - IndexOfAnyValueType<T>: SIMD search for any of 2-3 values - SequenceEqualValueType<T>: SIMD sequence comparison - ComputeFirstIndex/ComputeLastIndex: SIMD match index helpers UnmanagedSpanHelpers.cs: - Add Memmove() using NativeMemory.Copy - Add ClearWithoutReferences() using NativeMemory.Clear - Add IsAddressLessThanOrEqualTo<T>() for .NET 8 compatibility UnmanagedSpanExtensions.cs (rewritten): - Contains<T>: Dispatch to SIMD for numeric types - IndexOf<T>: Dispatch to SIMD for numeric types - LastIndexOf<T>: Dispatch to SIMD for numeric types - SequenceEqual<T>: Dispatch to SIMD for numeric types - Reverse<T>: Wrapper for SIMD reverse - Fill<T>: Wrapper for SIMD fill - BinarySearch<T>: Long-index binary search - StartsWith/EndsWith: Via SequenceEqual - CopyTo/TryCopyTo: Via Memmove Compatibility: - Works on both net8.0 and net10.0 - Conditional compilation for AVX-512 MoveMask (net9.0+) - Fallback to scalar loops when SIMD not available Removed: UnmanagedSpanHelpers.ByteMemOps.cs (consolidated into main file)
Remove int32 truncation throughout SIMD helper methods: UnmanagedSpanHelpers.T.cs: - All method signatures now use `long length` and return `long` - Loop variables changed from `int` to `long` - Unsafe.Add calls use `(nint)` cast for 64-bit platform support - Removed all `(int)` return casts - now returns full 64-bit indices - SequenceCompareTo uses `long minLength` UnmanagedSpanExtensions.cs: - Removed `(int)Math.Min(length, int.MaxValue)` truncation - All helper calls now pass full `long length` directly - SIMD paths use native long throughout This enables true >2 billion element support without chunking. The SIMD operations themselves already supported 64-bit via nuint offsets - only the wrapper code was truncating to int32.
…axValue Add three test files to verify long indexing support: 1. LongIndexingSmokeTest.cs (36 tests, CI-safe) - Uses 1M element arrays to verify long-indexed APIs - Tests Shape, NDArray creation, reductions, indexing, operations - Fast execution, minimal memory (~1MB per array) 2. LongIndexingMasterTest.cs (45 tests, requires 8GB+ RAM) - Uses int.MaxValue*1.1 elements (~2.36 billion) - Marked [Explicit] and [LongIndexing] to exclude from CI - Tests all np.* functions with large arrays sequentially 3. LongIndexingBroadcastTest.cs (20 tests, CI-safe) - Broadcasts scalar to int.MaxValue*1.1 size (~8 bytes memory) - Tests long indexing code paths without memory allocation - Exposes limitations: SliceDef int-limited, ops allocate full output Also: - Add [LongIndexing] category attribute to TestCategory.cs - Update CI workflow to exclude LongIndexing tests (too memory-intensive)
Previously, fancy indexing forced all index arrays to int32, which truncated int64 indices and prevented indexing beyond 2^31 elements. Changes: - Add NormalizeIndexArray() helper in NDArray.Indexing.Selection.cs - Keeps Int32/Int64 as-is (no conversion overhead) - Converts Byte/Int16/UInt16/UInt32/UInt64 → Int64 - Throws IndexOutOfRangeException for non-integer types (float, decimal, etc.) - Update Getter.cs and Setter.cs to use NormalizeIndexArray() instead of forced astype(NPTypeCode.Int32) conversion This matches NumPy behavior which accepts all integer types for indexing: - int8/16/32/64, uint8/16/32/64 → accepted - float32/64, decimal → IndexError PrepareIndexGetters() already supported both Int32 and Int64 paths, so no changes needed there. Battle tested with 20 test cases covering: - All 8 integer dtypes - Negative indices with signed types - 2D/3D array indexing - Mixed dtype indices - Empty/repeated indices - Out of bounds detection - Non-integer type rejection
Previously, assigning a scalar of different dtype to an array via fancy indexing produced zeros. For example: arr = np.arange(10) # int64 arr[[1,3,5]] = (NDArray)100 # int32 scalar -> gave [0, 0, 2, 0, ...] Root cause: AsOrMakeGeneric<T>() called `new NDArray<T>(astype(...))`. When astype returns a scalar NDArray, C# compiler chose: 1. Implicit conversion NDArray -> long (extracting scalar value 100) 2. Constructor NDArray<T>(long size) creating array of SIZE 100 Fix: Use `.Storage` to pass storage directly, avoiding the implicit conversion: `new NDArray<T>(converted.Storage)` Battle tested with 13 test cases covering: - Different scalar dtypes (int8/16/32/64, float32/64) on int64 array - Different array dtypes (int32/64, float32/64) with int scalar - 2D array scalar assignment - Single/repeated indices - Negative indices - Cross-dtype array value assignment
Since NDArray's == operator now returns NDArray<bool> for element-wise comparison (matching NumPy behavior), code using `arr == null` would either fail to compile or rely on implicit bool conversion which throws IncorrectShapeException for non-scalar arrays. Changed all NDArray null comparisons to use C# pattern matching: - `if (arr == null)` -> `if (arr is null)` - `if (arr != null)` -> `if (arr is not null)` This bypasses operator overloading and performs identity/reference checks. Files modified: - APIs/np.size.cs - Logic/np.all.cs, np.any.cs - Manipulation/np.atleastd.cs, np.copyto.cs - Selection/NDArray.Indexing.Selection.Getter.cs, Setter.cs - Backends/Default/Math/Reduction/Default.Reduction.Add.cs - Backends/Default/Math/Reduction/Default.Reduction.Std.cs - Backends/Default/Math/Reduction/Default.Reduction.Var.cs
Added 60 new tests to LongIndexingSmokeTest covering previously untested np.* functions with long-indexed arrays (1M elements). New coverage by category: - Unary math: abs, absolute, negative, positive, sqrt, cbrt, reciprocal, floor, ceil, trunc, sign, exp, exp2, expm1, log, log10, log1p, log2, sin, cos, tan - Binary math: divide, true_divide, floor_divide, mod, power, modf - Reductions: prod, std, var, cumprod - NaN-aware: nansum, nanmean, nanmin, nanmax, nanprod, nanstd, nanvar - Comparison: isnan, isinf, isfinite, array_equal, allclose, isclose - Shape: concatenate, stack, hstack, vstack, dstack, moveaxis, rollaxis, repeat - Sorting: argsort, nonzero, searchsorted - Creation: eye, identity, array - Other: around, copyto Test results: 94 passing, 2 OpenBugs - argsort: throws "index < Count, Memory corruption expected" - isinf: not implemented (Default.IsInf.cs returns null) All assertions derived from NumPy 2.x behavior via battletest.
Added 4 linear algebra tests to LongIndexingSmokeTest: - dot 1D: vector dot product with 1M elements - dot 2D: matrix multiplication (100x100) - matmul: matrix multiplication (100x100) - outer: outer product resulting in 1M element matrix All tests pass. Total smoke tests: 100 (98 passing, 2 OpenBugs).
Operator Overload Migration: - Arithmetic (+, -, *, /, %): Replace 120 explicit scalar overloads with 10 object-based overloads using np.asanyarray() for type conversion - Bitwise (&, |, ^): Already using object pattern, verified working - Comparison (==, !=, <, <=, >, >=): Already using object pattern - Unary (-, +, ~, !): Implemented, no object pattern needed Type Conversion Alignment (NumPy behavior): - scalar → NDArray: implicit (safe, creates 0-d array) - NDArray → scalar: explicit (requires 0-d, throws IncorrectShapeException) - This matches NumPy's int(arr), float(arr), bool(arr) pattern Null Check Migration: - Changed == null to is null throughout codebase - Reason: == now returns NDArray<bool> for element-wise comparison - is null performs identity check (matches NumPy's "is None" pattern) Code Reduction: - NDArray.Primitive.cs: 159 → 42 lines (74% reduction) - Total: ~150 explicit overloads → ~40 object-based overloads Added: - NDArray.BitwiseNot.cs: ~ operator implementation - NDArray.XOR.cs: ^ operator with object pattern - docs/OPERATOR_ALIGNMENT.md: Comprehensive operator documentation Fixed implicit conversions: - Added missing implicit operator NDArray(byte) - Changed ushort from explicit to implicit
Complete the NumPy-aligned API migration by replacing all `ValueType` parameters with `object` in the public API surface. This matches NumPy's `PyArray_FromAny` behavior where any input is accepted and converted via `np.asanyarray()`. Public API Changes: - np.power(arr, object) - scalar/array-like exponent - np.floor_divide(arr, object) - scalar/array-like divisor - np.left_shift(arr, object) - scalar/array-like shift - np.right_shift(arr, object) - scalar/array-like shift - np.full(object, ...) - scalar fill value (10 overloads) - np.equal/not_equal/less/greater/etc. - object pattern (12 overloads) - NDArray.itemset(object) - scalar value to set - NDArray.SetValue(object) - removed redundant ValueType overload - UnmanagedStorage.SetAtIndexUnsafe(object) - scalar value NumPy 2.x Alignment: - Added NDArray.item() method - the NumPy 2.x replacement for np.asscalar - item() - extract scalar from size-1 arrays - item(index) - flat indexing with negative index support - item(i, j) / item(i, j, k) - multi-dimensional indexing - item<T>() - type-converting variant - Marked np.asscalar as [Obsolete] (removed in NumPy 2.0) Internal Changes: - TensorEngine: removed ValueType overloads for Power, FloorDivide, Clip, LeftShift, RightShift (6 methods) - DefaultEngine: removed corresponding override implementations Fixes: - NumSharp.Bitmap: == null -> is null (2 occurrences) - examples/NeuralNetwork: == null -> is null - Tests: explicit casts for NDArray->scalar (3 files) - np.random.gamma: removed explicit ValueType cast
The argsort test was calling GetInt32() on an Int64 result array, causing "index < Count, Memory corruption expected" assertion. Root cause: np.argsort returns Int64 indices (correct NumPy behavior), but test used GetInt32() instead of GetInt64(). Fix: Changed GetInt32 to GetInt64 and added dtype assertion. OpenBugs reduced from 2 to 1 (only isinf remains unimplemented).
Completes the ValueType elimination from NumSharp's public API, aligning scalar extraction methods with the object pattern used for parameters. Changes: - UnmanagedStorage.GetValue(int[]/long[]) → returns object - UnmanagedStorage.GetAtIndex(long) → returns object - NDArray.GetValue(int[]/long[]) → returns object (keeps <T> overloads) - NDArray.GetAtIndex(long) → returns object (keeps <T> overload) - np.asscalar() → returns object (already deprecated) The <T> generic overloads remain for type-safe scalar extraction: - GetValue<T>(indices) for typed access - GetAtIndex<T>(index) for typed flat access - item<T>() for NumPy 2.x style extraction Also removes unnecessary (ValueType) cast in UnmanagedStorage.SetData.
Internal method parameter changes for consistency: - DefaultEngine.ClipScalar: ValueType min/max → object - DefaultEngine.ClipCore: ValueType min/max → object - DefaultEngine.ExecuteShiftOpScalar: ValueType rhs → object Removed unnecessary cast: - Default.Reduction.Add: removed (ValueType) cast on ChangeType result These are internal methods only, not affecting public API.
np.full and NDArray.Scalar now accept object directly, so explicit (ValueType) casts are no longer needed.
Changed return type from ValueType to object for consistency with the rest of the API migration. This also aligns with the duplicate ReductionTypeExtensions.GetDefaultValue which already returns object.
ReductionTypeExtensions.GetDefaultValue was identical to NPTypeCode.GetDefaultValue in NPTypeCode.cs. Removed the duplicate and added using NumSharp.Backends to access the canonical version. Note: GetMinValue/GetMaxValue in ReductionKernel are NOT duplicates of NumberInfo.MinValue/MaxValue - they use infinity for floats (correct for reduction identity).
Implements comprehensive NumPy type info functions: Type Info Classes: - np.iinfo: integer type limits (bits, min, max, kind) - np.finfo: floating point type limits (eps, precision, resolution, etc.) Type Checking Functions: - np.can_cast: check if type/value can be cast safely - np.result_type: determine result dtype from type promotion - np.promote_types: find smallest safe type for two dtypes - np.min_scalar_type: find smallest dtype that can hold a value - np.issubdtype: check type hierarchy relationships - np.common_type: find common float type for arrays - np.issctype, np.isdtype: check dtype categories - np.sctype2char: get character code for dtype - np.maximum_sctype: get highest precision type in category Array Type Checks: - np.isreal, np.iscomplex: element-wise real/complex check - np.isrealobj, np.iscomplexobj: check array dtype NPTypeCode Extensions: - GetOneValue: multiplicative identity for reductions - IsFloatingPoint: check if dtype is float/double/decimal - IsInteger: check if dtype is signed/unsigned integer - IsSimdCapable: check if dtype supports SIMD operations Internal Consolidation: - TypeRules now delegates to NPTypeCode extensions - ReductionKernel uses NPTypeCode.GetOneValue - Removed duplicate type info methods All functions match NumPy 2.x behavior.
…-compatible iteration Container protocol implementation: - __contains__ / Contains: membership testing via element-wise comparison - __hash__ / GetHashCode: throws NotSupportedException (NDArray is mutable/unhashable) - __len__: returns first dimension length, TypeError for 0-d scalars - __iter__ / GetEnumerator: NumPy-compatible iteration over first axis - __getitem__: indexing with int/long/string slice notation - __setitem__: assignment with int/long/string slice notation NumPy-compatible iteration behavior (BREAKING CHANGE): - 0-D arrays (scalars): throws TypeError (not iterable) - 1-D arrays: yields scalar elements - N-D arrays (N > 1): yields (N-1)-D NDArray slices along first axis This matches NumPy's behavior: >>> for x in np.array([[1,2],[3,4]]): print(x) [1 2] [3 4] Test updates for new iteration behavior: - Tests iterating over N-D arrays now use .flat.Cast<T>() for element-wise - Scalar value assertions use direct casting instead of iteration - Added comprehensive battle tests (69 tests) covering: - All 12 dtypes (Boolean, Byte, Int16-64, UInt16-64, Char, Single, Double, Decimal) - Edge cases: empty, scalar, sliced, strided, broadcast, transposed arrays - Negative indexing, type promotion, view semantics Files: - src/NumSharp.Core/Backends/NDArray.Container.cs (new) - src/NumSharp.Core/Backends/NDArray.cs (GetEnumerator updated) - src/NumSharp.Core/Exceptions/TypeError.cs (new) - test/NumSharp.UnitTest/Backends/ContainerProtocol*.cs (new) - Various test files updated to use .flat for element iteration
Round 2 battle tests focus on edge cases not covered in round 1: __len__ (6 new tests): - Large arrays (10000 elements) - First dimension = 1 - 5D arrays - After transpose changes first dimension - Negative strided slices - Slice of slice __getitem__ (9 new tests): - Long index positive/negative - 2D array with long index - Ellipsis handling - Complex slices (start:stop:step) - 2D column slicing - 2D submatrix extraction - View chaining preserves data __setitem__ (12 new tests): - Long index positive/negative - Broadcast scalar to 2D - Broadcast row to 2D (marked OpenBugs - NumPy supports, NumSharp doesn't) - Slice to slice assignment - Strided slice assignment - Type promotion int->double - Type promotion double->int (Misaligned - NumSharp rounds, NumPy truncates) - View modifies original __contains__ (12 new tests): - NaN in float/double arrays - Max/min values for int32/int64 - Type promotion byte->int32, int32->int64 - Zero in mixed sign array - Special floats (±inf, min, max) - Transposed/reversed arrays - Wrong type returns false (fixed Contains to catch exceptions) __iter__ (12 new tests): - View iteration - Nested iteration (3D) - Multiple independent enumerators - Reset throws NotSupportedException (documented behavior) - Transposed array iteration order - Sliced/strided/reversed array elements - Broadcast array iteration Fix in NDArray.Container.cs: - Contains now catches exceptions and returns false (NumPy-compatible) - Previously threw IncorrectShapeException for incompatible types Total: 120 container protocol tests (69 round 1 + 51 round 2)
NumPy's __contains__ does (self == el).any() and returns False for
incompatible types without throwing exceptions.
Issue: NumSharp's np.asanyarray("hello") creates char[5], while NumPy
creates a string scalar (). This caused IncorrectShapeException when
comparing int[3] with char[5] due to broadcast failure.
Fix: Check for type/shape compatibility before comparison:
- String in non-char array: return False immediately (incompatible types)
- String in char array with mismatched length: return False (shape mismatch)
- Non-scalar search value with incompatible 1D shapes: return False
This matches NumPy behavior:
- 'hello' in np.array([1,2,3]) → False (no exception)
- [1,2] in np.array([1,2,3]) → ValueError (shape mismatch - propagated)
The fix avoids try-catch by checking compatibility proactively, following
NumPy's approach of handling type comparisons gracefully.
Adds tolist() method that converts NDArray to nested List<object>: - 0-d arrays (scalars): returns the scalar value directly - 1-d arrays: returns List<object> of elements - n-d arrays: returns recursively nested List<object> structures Matches NumPy behavior exactly: - arr.tolist() on scalar returns int/float/etc - arr.tolist() on [1,2,3] returns list - arr.tolist() on [[1,2],[3,4]] returns nested lists This provides a NumPy-compatible alternative to the C#-specific ToArray<T>(), ToMuliDimArray<T>(), and ToJaggedArray<T>() methods.
…e battle tests API Overloads Added: - iinfo: generic iinfo<T>(), NDArray, string dtype overloads - finfo: generic finfo<T>(), NDArray, string dtype overloads - can_cast: all primitive type overloads (byte, short, ushort, uint, ulong, float, decimal, bool), generic can_cast<TFrom, TTo>() - result_type: two-arg convenience overloads for NPTypeCode, Type, NDArray - promote_types: generic promote_types<T1, T2>() - issubdtype: NDArray and Type+Type overloads - isdtype: Type and NDArray overloads Bug Fixes: - finfo: use MathF.BitIncrement for float eps calculation (was incorrectly using Math.BitIncrement which only operates on double) - issctype: properly reject string type (was returning true for typeof(string)) Battle Test Files Created (200+ tests): - np.iinfo.BattleTest.cs - np.finfo.BattleTest.cs - np.can_cast.BattleTest.cs - np.result_type.BattleTest.cs - np.promote_types.BattleTest.cs - np.min_scalar_type.BattleTest.cs - np.issubdtype.BattleTest.cs - np.common_type.BattleTest.cs - np.type_checks.BattleTest.cs (issctype, isdtype, sctype2char, maximum_sctype) - np.isreal_iscomplex.BattleTest.cs Note: np.dtype() string parsing has limitations - uses size+type format (e.g., "i4" for int32) rather than NumPy-style names like "int32"
Replace 80+ lines of switch cases with single-line derivation: CanCastSafe(A, B) = (A == B) || (_FindCommonType_Array(A, B) == B) This leverages the mathematical relationship: can_cast(A, B) ⟺ promote_types(A, B) == B Verified against NumPy for all 121 type pairs (11x11 matrix). Benefits: - Single source of truth for type hierarchy (promotion tables) - No duplicate type knowledge to maintain - Guaranteed consistency between can_cast and type promotion - Reduced code from ~90 lines to ~10 lines
NumPy's `__contains__` (the `in` operator) throws ValueError when shapes are incompatible for broadcasting. Previously, NumSharp caught these errors and returned False, which deviated from NumPy behavior. Changes: - Remove shape pre-check that returned False instead of throwing - Remove string length mismatch check for char arrays (now throws) - Keep string-in-non-char-array check (returns False, matches NumPy) Behavior change: - `[1,2] in np.array([1,2,3])` now throws IncorrectShapeException - `"hello" in np.array([1,2,3])` still returns False (type mismatch) - Broadcastable cases still work: `[1,2] in np.array([[1,2],[3,4]])` Added 50 battle tests covering: - Shape mismatch throws for all 12 dtypes - Broadcastable cases (scalar, row, column, N-D) - Type mismatch returns False (string in numeric arrays) - Char array special cases - Edge cases (NaN, Infinity, sliced/transposed views)
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Summary
Migrates all index, stride, offset, and size operations from
int(int32) tolong(int64), aligning NumSharp with NumPy'snpy_intptype. This enables support for arrays exceeding 2GB (int32 max = 2.1B elements) and ensures compatibility with NumPy 2.x behavior.Motivation
NumPy uses
npy_intp(equivalent toPy_ssize_t) for all indexing operations, which is 64-bit on x64 platforms. NumSharp's previous int32 limitation prevented working with large arrays and caused silent overflow bugs when array sizes approached int32 limits.Key drivers:
npy_intpsemanticsWhat Changed
size,dimensions,strides,offset,bufferSize→longGetOffset(),GetCoordinates(),TransformOffset()→longparameters and return typeslong[],int[]overloads delegate tolong[]int*→long*for strides/shapeslongCountproperty →longCountproperty and all index parameters →longCountproperty →longlong, addedlong[]overloadslong, addedlong[]overloadslongsize,lenproperties →longshape,stridesproperties →long[]long[]coordinate overloads,int[]delegates tolong[]long[]overloadsFunc<int[], int>→Func<long[], long>long[]long[]long[]long[]long[]longlonglongLdc_I4→Ldc_I8,Conv_I4→Conv_I8where appropriatelonglonglonglonglongnp.arange(int)andnp.arange(int, int, int)now returnint64arrays (NumPy 2.x alignment)np.argmax/np.argmin: return type →longnp.nonzero: return type →long[][]int*→long*, local stride calculations →longBreaking Changes
NDArray.sizereturnslongintif needed, or use directlyNDArray.shapereturnslong[]int[]NDArray.stridesreturnslong[]int[]np.arange(int)returnsint64dtype.astype(NPTypeCode.Int32)if int32 needednp.argmax/np.argminreturnlongintif needednp.nonzeroreturnslong[][]int[][]Shape[dim]returnslongintif neededlong[]Performance Impact
Benchmarked at 1-3% overhead for scalar loops, <1% overhead for SIMD-optimized paths. This is acceptable given the benefits of large array support.
longoffsets (zero overhead)What Stays
intNDArray.ndim/Shape.NDimSlice.Start/Stop/Stepfor (int d = 0; d < ndim; d++))NPTypeCodeenum valuesRelated
npy_intpdefined innumpy/_core/include/numpy/npy_common.h:217docs/INT64_DEVELOPER_GUIDE.md