Merge pull request #97 from dupontcyborg/full-arange-default-dtype

Updated default dtypes for full and arange

Author: dupontcyborg

benchmarks/src/validation.ts

@@ -1450,8 +1450,9 @@ export async function validateBenchmarks(specs: BenchmarkCase[]): Promise<void>
                 'unravel_index',
                 'random_permutation',
               ]);
-              // Integer creation functions: we return int32, NumPy returns int64
-              const INT_CREATION_OPS = new Set(['arange', 'full', 'full_like']);
+              // Integer creation functions: full/full_like return int32 (we
+              // diverge from NumPy's int64 to avoid BigInt for in-range fills).
+              const INT_CREATION_OPS = new Set(['full', 'full_like']);
               const isIndexOp = INDEX_OPS.has(spec.operation);
               const isIntCreation = INT_CREATION_OPS.has(spec.operation);
               if (
@@ -1460,6 +1461,12 @@ export async function validateBenchmarks(specs: BenchmarkCase[]): Promise<void>
                 (npDtype === 'int64' || npDtype === 'uint64')
               ) {
                 // Accepted: index ops return float64 for JS ergonomics
+              } else if (
+                spec.operation === 'arange' &&
+                tsDtype === 'float64' &&
+                npDtype === 'int64'
+              ) {
+                // Accepted: arange defaults to float64 (matches zeros/ones/linspace)
               } else if (isIntCreation && tsDtype === 'int32' && npDtype === 'int64') {
                 // Accepted: int32 is our int64 equivalent for non-BigInt JS numbers
               } else if (

src/core/creation.ts

@@ -86,8 +86,8 @@ export function full(
     } else if (typeof fill_value === 'boolean') {
       actualDtype = 'bool';
     } else if (Number.isInteger(fill_value)) {
-      // Integers outside int32 range default to float64 (matches NumPy)
-      actualDtype = fill_value >= -2147483648 && fill_value <= 2147483647 ? 'int32' : 'float64';
+      // Integer fill: int32 if it fits, otherwise int64 for the wider range.
+      actualDtype = fill_value >= -2147483648 && fill_value <= 2147483647 ? 'int32' : 'int64';
     } else {
       actualDtype = DEFAULT_DTYPE;
     }
@@ -283,18 +283,9 @@ export function arange(start: number, stop?: number, step: number = 1, dtype?: D
 
   const length = Math.max(0, Math.ceil((actualStop - actualStart) / step));
 
-  // Infer dtype from arguments: all integers that fit in int32 → int32, else float64
-  const INT32_MAX = 2147483647;
-  const INT32_MIN = -2147483648;
-  const allInt =
-    Number.isInteger(actualStart) && Number.isInteger(actualStop) && Number.isInteger(step);
-  const lastVal = length > 0 ? actualStart + (length - 1) * step : actualStart;
-  const fitsInt32 =
-    actualStart >= INT32_MIN &&
-    actualStart <= INT32_MAX &&
-    lastVal >= INT32_MIN &&
-    lastVal <= INT32_MAX;
-  const actualDtype = dtype ?? (allInt && fitsInt32 ? 'int32' : DEFAULT_DTYPE);
+  // Default to float64 for consistency with zeros/ones/empty/linspace.
+  // Diverges from NumPy (which returns int64 for integer args) to avoid BigInt.
+  const actualDtype = dtype ?? DEFAULT_DTYPE;
 
   // bool arange only valid for length ≤ 2: [False] or [False, True]
   if (actualDtype === 'bool' && length > 2) {

tests/unit/creation.test.ts

@@ -77,22 +77,26 @@ describe('Array Creation Functions', () => {
       expect(arr.toArray()).toEqual([]);
     });
 
-    it('infers int32 dtype for integer args', () => {
-      expect(arange(10).dtype).toBe('int32');
+    it('defaults to float64 dtype for integer args', () => {
+      expect(arange(10).dtype).toBe('float64');
     });
 
-    it('infers int32 dtype for all-integer start/stop/step', () => {
-      expect(arange(0, 10, 1).dtype).toBe('int32');
+    it('defaults to float64 dtype for all-integer start/stop/step', () => {
+      expect(arange(0, 10, 1).dtype).toBe('float64');
     });
 
-    it('infers float64 dtype for float step', () => {
+    it('defaults to float64 dtype for float step', () => {
       expect(arange(0, 10, 0.5).dtype).toBe('float64');
     });
 
-    it('infers float64 dtype when args overflow int32', () => {
+    it('defaults to float64 dtype when args overflow int32', () => {
       expect(arange(0, 3e9, 1e8).dtype).toBe('float64');
     });
 
+    it('honors explicit dtype override', () => {
+      expect(arange(0, 10, 1, 'int32').dtype).toBe('int32');
+    });
+
     it('respects explicit dtype over inference', () => {
       expect(arange(10, undefined, 1, 'float64').dtype).toBe('float64');
     });
@@ -348,16 +352,22 @@ describe('Array Creation Functions', () => {
       expect(arr.dtype).toBe('float64');
     });
 
-    it('infers float64 dtype for overflow fill value', () => {
-      expect(full([2], 3e9).dtype).toBe('float64');
+    it('infers int64 dtype for overflow fill value', () => {
+      expect(full([2], 3e9).dtype).toBe('int64');
     });
 
     it('infers int32 dtype for max int32 fill value', () => {
       expect(full([2], 2147483647).dtype).toBe('int32');
     });
 
-    it('infers float64 dtype for int32 overflow fill value', () => {
-      expect(full([2], 2147483648).dtype).toBe('float64');
+    it('infers int64 dtype for int32 overflow fill value', () => {
+      expect(full([2], 2147483648).dtype).toBe('int64');
+    });
+
+    it('stores correct value when inferring int64 from a JS number', () => {
+      const arr = full([2], 3e9);
+      expect(arr.get([0])).toBe(3000000000n);
+      expect(arr.get([1])).toBe(3000000000n);
     });
   });