numpy-ts 0.1.0

package/dist/types/core/broadcasting.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Broadcasting utilities for NumPy-compatible array operations
+ *
+ * Wraps @stdlib broadcasting functions with NumPy-compatible API
+ */
+type StdlibNDArray = any;
+/**
+ * Check if two or more shapes are broadcast-compatible
+ * and compute the resulting output shape
+ *
+ * @param shapes - Array of shapes to broadcast
+ * @returns The broadcast output shape, or null if incompatible
+ *
+ * @example
+ * ```typescript
+ * computeBroadcastShape([[3, 4], [4]]);     // [3, 4]
+ * computeBroadcastShape([[3, 4], [3, 1]]);  // [3, 4]
+ * computeBroadcastShape([[3, 4], [5]]);     // null (incompatible)
+ * ```
+ */
+export declare function computeBroadcastShape(shapes: readonly number[][]): number[] | null;
+/**
+ * Check if two shapes are broadcast-compatible
+ *
+ * @param shape1 - First shape
+ * @param shape2 - Second shape
+ * @returns true if shapes can be broadcast together, false otherwise
+ *
+ * @example
+ * ```typescript
+ * areBroadcastable([3, 4], [4]);      // true
+ * areBroadcastable([3, 4], [3, 1]);   // true
+ * areBroadcastable([3, 4], [5]);      // false
+ * ```
+ */
+export declare function areBroadcastable(shape1: readonly number[], shape2: readonly number[]): boolean;
+/**
+ * Broadcast multiple stdlib ndarrays to a common shape
+ *
+ * Returns read-only views of the input arrays broadcast to the same shape.
+ * Views share memory with the original arrays.
+ *
+ * @param arrays - Stdlib ndarrays to broadcast
+ * @returns Array of broadcast stdlib ndarrays
+ * @throws Error if arrays have incompatible shapes
+ *
+ * @example
+ * ```typescript
+ * const [a, b] = broadcastStdlibArrays([arr1._data, arr2._data]);
+ * ```
+ */
+export declare function broadcastStdlibArrays(arrays: StdlibNDArray[]): StdlibNDArray[];
+/**
+ * Generate a descriptive error message for broadcasting failures
+ *
+ * @param shapes - The incompatible shapes
+ * @param operation - The operation being attempted (e.g., 'add', 'multiply')
+ * @returns Error message string
+ */
+export declare function broadcastErrorMessage(shapes: readonly number[][], operation?: string): string;
+export {};
+//# sourceMappingURL=broadcasting.d.ts.map

package/dist/types/core/dtype.d.ts

@@ -0,0 +1,66 @@
+/**
+ * DType (Data Type) system for numpy-ts
+ *
+ * Supports NumPy numeric types:
+ * - Floating point: float32, float64
+ * - Signed integers: int8, int16, int32, int64
+ * - Unsigned integers: uint8, uint16, uint32, uint64
+ * - Boolean: bool
+ */
+/**
+ * All supported dtypes
+ */
+export type DType = 'float64' | 'float32' | 'int64' | 'int32' | 'int16' | 'int8' | 'uint64' | 'uint32' | 'uint16' | 'uint8' | 'bool';
+/**
+ * TypedArray types for each dtype
+ */
+export type TypedArray = Float64Array | Float32Array | BigInt64Array | Int32Array | Int16Array | Int8Array | BigUint64Array | Uint32Array | Uint16Array | Uint8Array;
+/**
+ * Default dtype (matches NumPy)
+ */
+export declare const DEFAULT_DTYPE: DType;
+/**
+ * Get the TypedArray constructor for a given dtype
+ */
+export declare function getTypedArrayConstructor(dtype: DType): TypedArrayConstructor | null;
+type TypedArrayConstructor = Float64ArrayConstructor | Float32ArrayConstructor | BigInt64ArrayConstructor | Int32ArrayConstructor | Int16ArrayConstructor | Int8ArrayConstructor | BigUint64ArrayConstructor | Uint32ArrayConstructor | Uint16ArrayConstructor | Uint8ArrayConstructor;
+/**
+ * Get the element size in bytes for a given dtype
+ */
+export declare function getDTypeSize(dtype: DType): number;
+/**
+ * Check if dtype is integer
+ */
+export declare function isIntegerDType(dtype: DType): boolean;
+/**
+ * Check if dtype is floating point
+ */
+export declare function isFloatDType(dtype: DType): boolean;
+/**
+ * Check if dtype uses BigInt
+ */
+export declare function isBigIntDType(dtype: DType): boolean;
+/**
+ * Infer dtype from JavaScript value
+ */
+export declare function inferDType(value: unknown): DType;
+/**
+ * Promote two dtypes to a common dtype
+ * Follows NumPy's type promotion rules
+ */
+export declare function promoteDTypes(dtype1: DType, dtype2: DType): DType;
+/**
+ * Validate dtype string
+ */
+export declare function isValidDType(dtype: string): dtype is DType;
+/**
+ * Convert value to the appropriate type for the given dtype
+ */
+export declare function castValue(value: number | bigint | boolean, dtype: DType): number | bigint;
+/**
+ * Map our dtype to @stdlib's supported dtype
+ * @stdlib doesn't support int64, uint64 natively, but does support bool
+ */
+export declare function toStdlibDType(dtype: DType): string;
+export {};
+//# sourceMappingURL=dtype.d.ts.map

package/dist/types/core/ndarray.d.ts

@@ -0,0 +1,387 @@
+/**
+ * NDArray - NumPy-compatible multidimensional array
+ *
+ * Thin wrapper around @stdlib/ndarray providing NumPy-like API
+ */
+import { type DType, type TypedArray } from './dtype';
+import { ArrayStorage } from './storage';
+type StdlibNDArray = any;
+export declare class NDArray {
+    private _data;
+    private _dtype?;
+    private _base?;
+    constructor(stdlibArray: StdlibNDArray, dtype?: DType, base?: NDArray);
+    /**
+     * Get internal storage (for ops modules)
+     * @internal
+     */
+    get _storage(): ArrayStorage;
+    /**
+     * Create NDArray from storage (for ops modules)
+     * @internal
+     */
+    static _fromStorage(storage: ArrayStorage, base?: NDArray): NDArray;
+    get shape(): readonly number[];
+    get ndim(): number;
+    get size(): number;
+    get dtype(): string;
+    get data(): TypedArray;
+    get strides(): readonly number[];
+    /**
+     * Array flags (similar to NumPy's flags)
+     * Provides information about memory layout
+     */
+    get flags(): {
+        C_CONTIGUOUS: boolean;
+        F_CONTIGUOUS: boolean;
+        OWNDATA: boolean;
+    };
+    /**
+     * Base array if this is a view, null if this array owns its data
+     * Similar to NumPy's base attribute
+     */
+    get base(): NDArray | null;
+    /**
+     * Get a single element from the array
+     * @param indices - Array of indices, one per dimension (e.g., [0, 1] for 2D array)
+     * @returns The element value (BigInt for int64/uint64, number otherwise)
+     *
+     * @example
+     * ```typescript
+     * const arr = array([[1, 2], [3, 4]]);
+     * arr.get([0, 1]);  // Returns 2
+     * arr.get([-1, -1]); // Returns 4 (negative indexing supported)
+     * ```
+     */
+    get(indices: number[]): number | bigint;
+    /**
+     * Set a single element in the array
+     * @param indices - Array of indices, one per dimension (e.g., [0, 1] for 2D array)
+     * @param value - Value to set (will be converted to array's dtype)
+     *
+     * @example
+     * ```typescript
+     * const arr = zeros([2, 3]);
+     * arr.set([0, 1], 42);  // Set element at position [0, 1] to 42
+     * arr.set([-1, -1], 99); // Set last element to 99 (negative indexing supported)
+     * ```
+     */
+    set(indices: number[], value: number | bigint): void;
+    /**
+     * Return a deep copy of the array
+     * Creates a new array with copied data (not a view)
+     *
+     * @returns Deep copy of the array
+     *
+     * @example
+     * ```typescript
+     * const arr = array([[1, 2], [3, 4]]);
+     * const copied = arr.copy();
+     * copied.set([0, 0], 99);  // Doesn't affect original
+     * console.log(arr.get([0, 0]));  // Still 1
+     * ```
+     */
+    copy(): NDArray;
+    /**
+     * Cast array to a different dtype
+     * @param dtype - Target dtype
+     * @param copy - If false and dtype matches, return self; otherwise create copy (default: true)
+     * @returns Array with specified dtype
+     */
+    astype(dtype: DType, copy?: boolean): NDArray;
+    /**
+     * Helper method for element-wise operations with broadcasting
+     * @private
+     */
+    add(other: NDArray | number): NDArray;
+    subtract(other: NDArray | number): NDArray;
+    multiply(other: NDArray | number): NDArray;
+    divide(other: NDArray | number): NDArray;
+    /**
+     * Element-wise greater than comparison
+     * @param other - Value or array to compare with
+     * @returns Boolean array (represented as uint8: 1=true, 0=false)
+     */
+    greater(other: NDArray | number): NDArray;
+    /**
+     * Element-wise greater than or equal comparison
+     * @param other - Value or array to compare with
+     * @returns Boolean array (represented as uint8: 1=true, 0=false)
+     */
+    greater_equal(other: NDArray | number): NDArray;
+    /**
+     * Element-wise less than comparison
+     * @param other - Value or array to compare with
+     * @returns Boolean array (represented as uint8: 1=true, 0=false)
+     */
+    less(other: NDArray | number): NDArray;
+    /**
+     * Element-wise less than or equal comparison
+     * @param other - Value or array to compare with
+     * @returns Boolean array (represented as uint8: 1=true, 0=false)
+     */
+    less_equal(other: NDArray | number): NDArray;
+    /**
+     * Element-wise equality comparison
+     * @param other - Value or array to compare with
+     * @returns Boolean array (represented as uint8: 1=true, 0=false)
+     */
+    equal(other: NDArray | number): NDArray;
+    /**
+     * Element-wise not equal comparison
+     * @param other - Value or array to compare with
+     * @returns Boolean array (represented as uint8: 1=true, 0=false)
+     */
+    not_equal(other: NDArray | number): NDArray;
+    /**
+     * Element-wise comparison with tolerance
+     * Returns True where |a - b| <= (atol + rtol * |b|)
+     * @param other - Value or array to compare with
+     * @param rtol - Relative tolerance (default: 1e-5)
+     * @param atol - Absolute tolerance (default: 1e-8)
+     * @returns Boolean array (represented as uint8: 1=true, 0=false)
+     */
+    isclose(other: NDArray | number, rtol?: number, atol?: number): NDArray;
+    allclose(other: NDArray | number, rtol?: number, atol?: number): boolean;
+    /**
+     * Helper method for isclose operation with broadcasting
+     * @private
+     */
+    /**
+     * Helper method for comparison operations with broadcasting
+     * @private
+     */
+    /**
+     * Sum array elements over a given axis
+     * @param axis - Axis along which to sum. If undefined, sum all elements
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     * @returns Sum of array elements, or array of sums along axis
+     */
+    sum(axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Compute the arithmetic mean along the specified axis
+     * @param axis - Axis along which to compute mean. If undefined, compute mean of all elements
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     * @returns Mean of array elements, or array of means along axis
+     *
+     * Note: mean() returns float64 for integer dtypes, matching NumPy behavior
+     */
+    mean(axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Return the maximum along a given axis
+     * @param axis - Axis along which to compute maximum. If undefined, compute maximum of all elements
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     * @returns Maximum of array elements, or array of maximums along axis
+     */
+    max(axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Return the minimum along a given axis
+     * @param axis - Axis along which to compute minimum. If undefined, compute minimum of all elements
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     * @returns Minimum of array elements, or array of minimums along axis
+     */
+    min(axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Product of array elements over a given axis
+     * @param axis - Axis along which to compute the product. If undefined, product of all elements.
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     * @returns Product of array elements, or array of products along axis
+     */
+    prod(axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Indices of the minimum values along an axis
+     * @param axis - Axis along which to find minimum indices. If undefined, index of global minimum.
+     * @returns Indices of minimum values
+     */
+    argmin(axis?: number): NDArray | number;
+    /**
+     * Indices of the maximum values along an axis
+     * @param axis - Axis along which to find maximum indices. If undefined, index of global maximum.
+     * @returns Indices of maximum values
+     */
+    argmax(axis?: number): NDArray | number;
+    /**
+     * Compute variance along the specified axis
+     * @param axis - Axis along which to compute variance. If undefined, variance of all elements.
+     * @param ddof - Delta degrees of freedom (default: 0)
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     * @returns Variance of array elements
+     */
+    var(axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Compute standard deviation along the specified axis
+     * @param axis - Axis along which to compute std. If undefined, std of all elements.
+     * @param ddof - Delta degrees of freedom (default: 0)
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     * @returns Standard deviation of array elements
+     */
+    std(axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Test whether all array elements along a given axis evaluate to True
+     * @param axis - Axis along which to perform logical AND. If undefined, test all elements.
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     * @returns Boolean or array of booleans
+     */
+    all(axis?: number, keepdims?: boolean): NDArray | boolean;
+    /**
+     * Test whether any array elements along a given axis evaluate to True
+     * @param axis - Axis along which to perform logical OR. If undefined, test all elements.
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     * @returns Boolean or array of booleans
+     */
+    any(axis?: number, keepdims?: boolean): NDArray | boolean;
+    /**
+     * Reshape array to a new shape
+     * Returns a new array with the specified shape
+     * @param shape - New shape (must be compatible with current size)
+     * @returns Reshaped array
+     */
+    reshape(...shape: number[]): NDArray;
+    /**
+     * Return a flattened copy of the array
+     * @returns 1D array containing all elements
+     */
+    flatten(): NDArray;
+    /**
+     * Return a flattened array (view when possible, otherwise copy)
+     * @returns 1D array containing all elements
+     */
+    ravel(): NDArray;
+    /**
+     * Transpose array (permute dimensions)
+     * @param axes - Permutation of axes. If undefined, reverse the dimensions
+     * @returns Transposed array (always a view)
+     */
+    transpose(axes?: number[]): NDArray;
+    /**
+     * Remove axes of length 1
+     * @param axis - Axis to squeeze. If undefined, squeeze all axes of length 1
+     * @returns Array with specified dimensions removed (always a view)
+     */
+    squeeze(axis?: number): NDArray;
+    /**
+     * Expand the shape by inserting a new axis of length 1
+     * @param axis - Position where new axis is placed
+     * @returns Array with additional dimension (always a view)
+     */
+    expand_dims(axis: number): NDArray;
+    matmul(other: NDArray): NDArray;
+    /**
+     * Slice the array using NumPy-style string syntax
+     *
+     * @param sliceStrs - Slice specifications, one per dimension
+     * @returns Sliced view of the array
+     *
+     * @example
+     * ```typescript
+     * const arr = array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
+     * const row = arr.slice('0', ':');     // First row: [1, 2, 3]
+     * const col = arr.slice(':', '1');     // Second column: [2, 5, 8]
+     * const sub = arr.slice('0:2', '1:3'); // Top-right 2x2: [[2, 3], [5, 6]]
+     * ```
+     */
+    slice(...sliceStrs: string[]): NDArray;
+    /**
+     * Get a single row (convenience method)
+     * @param i - Row index
+     * @returns Row as 1D or (n-1)D array
+     */
+    row(i: number): NDArray;
+    /**
+     * Get a single column (convenience method)
+     * @param j - Column index
+     * @returns Column as 1D or (n-1)D array
+     */
+    col(j: number): NDArray;
+    /**
+     * Get a range of rows (convenience method)
+     * @param start - Start row index
+     * @param stop - Stop row index (exclusive)
+     * @returns Rows as array
+     */
+    rows(start: number, stop: number): NDArray;
+    /**
+     * Get a range of columns (convenience method)
+     * @param start - Start column index
+     * @param stop - Stop column index (exclusive)
+     * @returns Columns as array
+     */
+    cols(start: number, stop: number): NDArray;
+    toString(): string;
+    toArray(): any;
+}
+/**
+ * Create array of zeros
+ */
+export declare function zeros(shape: number[], dtype?: DType): NDArray;
+/**
+ * Create array of ones
+ */
+export declare function ones(shape: number[], dtype?: DType): NDArray;
+/**
+ * Create array from nested JavaScript arrays
+ */
+export declare function array(data: any, dtype?: DType): NDArray;
+/**
+ * Create array with evenly spaced values within a given interval
+ * Similar to Python's range() but returns floats
+ */
+export declare function arange(start: number, stop?: number, step?: number, dtype?: DType): NDArray;
+/**
+ * Create array with evenly spaced values over a specified interval
+ */
+export declare function linspace(start: number, stop: number, num?: number, dtype?: DType): NDArray;
+/**
+ * Create array with logarithmically spaced values
+ * Returns num samples, equally spaced on a log scale from base^start to base^stop
+ */
+export declare function logspace(start: number, stop: number, num?: number, base?: number, dtype?: DType): NDArray;
+/**
+ * Create array with geometrically spaced values
+ * Returns num samples, equally spaced on a log scale (geometric progression)
+ */
+export declare function geomspace(start: number, stop: number, num?: number, dtype?: DType): NDArray;
+/**
+ * Create identity matrix
+ */
+export declare function eye(n: number, m?: number, k?: number, dtype?: DType): NDArray;
+/**
+ * Create an uninitialized array
+ * Note: Unlike NumPy, TypedArrays are zero-initialized by default in JavaScript
+ */
+export declare function empty(shape: number[], dtype?: DType): NDArray;
+/**
+ * Create array filled with a constant value
+ */
+export declare function full(shape: number[], fill_value: number | bigint | boolean, dtype?: DType): NDArray;
+/**
+ * Create a square identity matrix
+ */
+export declare function identity(n: number, dtype?: DType): NDArray;
+/**
+ * Convert input to an ndarray
+ * If input is already an NDArray, optionally convert dtype
+ */
+export declare function asarray(a: NDArray | any, dtype?: DType): NDArray;
+/**
+ * Create a deep copy of an array
+ */
+export declare function copy(a: NDArray): NDArray;
+/**
+ * Create array of zeros with the same shape as another array
+ */
+export declare function zeros_like(a: NDArray, dtype?: DType): NDArray;
+/**
+ * Create array of ones with the same shape as another array
+ */
+export declare function ones_like(a: NDArray, dtype?: DType): NDArray;
+/**
+ * Create uninitialized array with the same shape as another array
+ */
+export declare function empty_like(a: NDArray, dtype?: DType): NDArray;
+/**
+ * Create array filled with a constant value, same shape as another array
+ */
+export declare function full_like(a: NDArray, fill_value: number | bigint | boolean, dtype?: DType): NDArray;
+export {};
+//# sourceMappingURL=ndarray.d.ts.map

package/dist/types/core/slicing.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Slicing utilities for NumPy-compatible array indexing
+ *
+ * Supports Python-style slice syntax via strings: "0:5", ":", "::2", "-1"
+ */
+/**
+ * Represents a parsed slice specification
+ */
+export interface SliceSpec {
+    start: number | null;
+    stop: number | null;
+    step: number;
+    isIndex: boolean;
+}
+/**
+ * Parse a slice string into a SliceSpec
+ *
+ * Supports:
+ * - Single index: "5", "-1"
+ * - Full slice: "0:5", "2:8"
+ * - With step: "0:10:2", "::2"
+ * - Partial: "5:", ":10", ":"
+ * - Negative: "-5:", ":-2", "::-1"
+ *
+ * @param sliceStr - String representation of slice (e.g., "0:5", ":", "::2")
+ * @returns Parsed slice specification
+ *
+ * @example
+ * ```typescript
+ * parseSlice("0:5")    // {start: 0, stop: 5, step: 1, isIndex: false}
+ * parseSlice(":")      // {start: null, stop: null, step: 1, isIndex: false}
+ * parseSlice("::2")    // {start: null, stop: null, step: 2, isIndex: false}
+ * parseSlice("-1")     // {start: -1, stop: null, step: 1, isIndex: true}
+ * parseSlice("5")      // {start: 5, stop: null, step: 1, isIndex: true}
+ * ```
+ */
+export declare function parseSlice(sliceStr: string): SliceSpec;
+/**
+ * Normalize a slice specification to absolute indices
+ *
+ * Handles negative indices and defaults:
+ * - Negative indices count from the end
+ * - null start becomes 0 (or size-1 for negative step)
+ * - null stop becomes size (or -1 for negative step)
+ *
+ * @param spec - Parsed slice specification
+ * @param size - Size of the dimension being sliced
+ * @returns Normalized slice with absolute start, stop, step
+ *
+ * @example
+ * ```typescript
+ * normalizeSlice({start: -1, stop: null, step: 1, isIndex: true}, 10)
+ * // {start: 9, stop: 10, step: 1, isIndex: true}
+ *
+ * normalizeSlice({start: null, stop: -2, step: 1, isIndex: false}, 10)
+ * // {start: 0, stop: 8, step: 1, isIndex: false}
+ * ```
+ */
+export declare function normalizeSlice(spec: SliceSpec, size: number): {
+    start: number;
+    stop: number;
+    step: number;
+    isIndex: boolean;
+};
+/**
+ * Compute the length of a slice result
+ *
+ * @param start - Normalized start index
+ * @param stop - Normalized stop index
+ * @param step - Step value
+ * @returns Number of elements in the slice
+ */
+export declare function computeSliceLength(start: number, stop: number, step: number): number;
+/**
+ * Parse multiple slice specifications for multi-dimensional indexing
+ *
+ * @param sliceStrs - Array of slice strings, one per dimension
+ * @returns Array of parsed slice specifications
+ *
+ * @example
+ * ```typescript
+ * parseSlices(["0:5", ":", "::2"])
+ * // [
+ * //   {start: 0, stop: 5, step: 1, isIndex: false},
+ * //   {start: null, stop: null, step: 1, isIndex: false},
+ * //   {start: null, stop: null, step: 2, isIndex: false}
+ * // ]
+ * ```
+ */
+export declare function parseSlices(sliceStrs: string[]): SliceSpec[];
+//# sourceMappingURL=slicing.d.ts.map

package/dist/types/core/storage.d.ts

@@ -0,0 +1,92 @@
+/**
+ * ArrayStorage - Internal storage abstraction
+ *
+ * Wraps @stdlib/ndarray to provide a clean internal interface
+ * while keeping stdlib as an implementation detail.
+ *
+ * @internal - This is not part of the public API
+ */
+import type { ndarray as StdlibNDArray } from '@stdlib/types/ndarray';
+import { type DType, type TypedArray } from './dtype';
+/**
+ * Internal storage for NDArray data
+ * Manages the underlying TypedArray and metadata
+ */
+export declare class ArrayStorage {
+    private _stdlib;
+    private _dtype;
+    constructor(stdlibArray: StdlibNDArray, dt?: DType);
+    /**
+     * Shape of the array
+     */
+    get shape(): readonly number[];
+    /**
+     * Number of dimensions
+     */
+    get ndim(): number;
+    /**
+     * Total number of elements
+     */
+    get size(): number;
+    /**
+     * Data type
+     */
+    get dtype(): DType;
+    /**
+     * Underlying data buffer
+     */
+    get data(): TypedArray;
+    /**
+     * Strides (steps in each dimension)
+     */
+    get strides(): readonly number[];
+    /**
+     * Direct access to stdlib ndarray (for internal use)
+     * @internal
+     */
+    get stdlib(): StdlibNDArray;
+    /**
+     * Check if array is C-contiguous (row-major, no gaps)
+     */
+    get isCContiguous(): boolean;
+    /**
+     * Check if array is F-contiguous (column-major, no gaps)
+     */
+    get isFContiguous(): boolean;
+    /**
+     * Create a deep copy of this storage
+     */
+    copy(): ArrayStorage;
+    /**
+     * Create storage from stdlib ndarray
+     */
+    static fromStdlib(stdlibArray: StdlibNDArray, dtype?: DType): ArrayStorage;
+    /**
+     * Create storage from TypedArray data
+     */
+    static fromData(data: TypedArray, shape: number[], dtype: DType): ArrayStorage;
+    /**
+     * Create storage with zeros
+     */
+    static zeros(shape: number[], dtype?: DType): ArrayStorage;
+    /**
+     * Create storage with ones
+     */
+    static ones(shape: number[], dtype?: DType): ArrayStorage;
+    /**
+     * Compute strides for row-major (C-order) layout
+     * @private
+     */
+    private _computeStrides;
+    /**
+     * Compute strides for row-major (C-order) layout
+     * @private
+     */
+    private static _computeStrides;
+}
+/**
+ * Compute strides for a given shape (row-major order)
+ * @internal
+ */
+export declare function computeStrides(shape: readonly number[]): number[];
+//# sourceMappingURL=storage.d.ts.map