numpy-ts 0.4.0 → 0.6.0

package/dist/types/index.d.ts

@@ -3,6 +3,7 @@
  *
  * @module numpy-ts
  */
-export { NDArray, zeros, ones, array, arange, linspace, logspace, geomspace, eye, empty, full, identity, asarray, copy, zeros_like, ones_like, empty_like, full_like, sqrt, power, absolute, negative, sign, mod, floor_divide, positive, reciprocal, dot, trace, transpose, inner, outer, tensordot, } from './core/ndarray';
+export { NDArray, zeros, ones, array, arange, linspace, logspace, geomspace, eye, empty, full, identity, asarray, copy, zeros_like, ones_like, empty_like, full_like, asanyarray, ascontiguousarray, asfortranarray, diag, diagflat, frombuffer, fromfile, fromfunction, fromiter, fromstring, meshgrid, tri, tril, triu, vander, sqrt, power, absolute, negative, sign, mod, floor_divide, positive, reciprocal, cbrt, fabs, divmod, square, remainder, heaviside, dot, trace, diagonal, kron, transpose, inner, outer, tensordot, einsum, sin, cos, tan, arcsin, arccos, arctan, arctan2, hypot, degrees, radians, deg2rad, rad2deg, sinh, cosh, tanh, arcsinh, arccosh, arctanh, swapaxes, moveaxis, concatenate, stack, vstack, hstack, dstack, split, array_split, vsplit, hsplit, tile, repeat, ravel, reshape, squeeze, expand_dims, flip, fliplr, flipud, rot90, roll, rollaxis, atleast_1d, atleast_2d, atleast_3d, dsplit, column_stack, row_stack, resize, append, delete_ as delete, insert, pad, broadcast_to, broadcast_arrays, broadcast_shapes, take, put, choose, array_equal, array_equiv, cumsum, cumprod, ptp, median, percentile, quantile, average, nansum, nanprod, nanmean, nanvar, nanstd, nanmin, nanmax, nanargmin, nanargmax, nancumsum, nancumprod, nanmedian, } from './core/ndarray';
+export { parseNpy, serializeNpy, parseNpyHeader, parseNpyData, UnsupportedDTypeError, InvalidNpyError, SUPPORTED_DTYPES, DTYPE_TO_DESCR, type NpyHeader, type NpyMetadata, type NpyVersion, parseNpz, parseNpzSync, loadNpz, loadNpzSync, serializeNpz, serializeNpzSync, type NpzParseOptions, type NpzParseResult, type NpzSerializeOptions, } from './io';
 export declare const __version__: string;
 //# sourceMappingURL=index.d.ts.map

package/dist/types/io/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * IO module for numpy-ts
+ *
+ * This module provides parsing and serialization for NPY and NPZ formats.
+ * These functions work with bytes (Uint8Array/ArrayBuffer) and are environment-agnostic.
+ *
+ * For file system operations (save/load), use the Node.js-specific entry point:
+ *   import { save, load } from 'numpy-ts/node';
+ *
+ * For browser usage, use fetch or FileReader to get the bytes, then use these functions.
+ */
+export { parseNpy, parseNpyHeader, parseNpyData } from './npy/parser';
+export { serializeNpy } from './npy/serializer';
+export { UnsupportedDTypeError, InvalidNpyError, SUPPORTED_DTYPES, DTYPE_TO_DESCR, type NpyHeader, type NpyMetadata, type NpyVersion, } from './npy/format';
+export { parseNpz, parseNpzSync, loadNpz, loadNpzSync, type NpzParseOptions, type NpzParseResult, } from './npz/parser';
+export { serializeNpz, serializeNpzSync, type NpzSerializeOptions } from './npz/serializer';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/io/npy/format.d.ts

@@ -0,0 +1,91 @@
+/**
+ * NPY file format constants and type definitions
+ *
+ * NPY is NumPy's native binary format for storing arrays.
+ * Spec: https://numpy.org/doc/stable/reference/generated/numpy.lib.format.html
+ */
+import type { DType } from '../../core/dtype';
+/**
+ * NPY magic number: \x93NUMPY (6 bytes)
+ */
+export declare const NPY_MAGIC: Uint8Array<ArrayBuffer>;
+/**
+ * Supported NPY format versions
+ * - v1.0: 2-byte header length (max 65535 bytes)
+ * - v2.0: 4-byte header length (max 4GB)
+ * - v3.0: allows UTF-8 in description (same as v2 otherwise)
+ *
+ * We read v1, v2, and v3; we write v2 only
+ */
+export interface NpyVersion {
+    major: number;
+    minor: number;
+}
+/**
+ * NPY header information
+ */
+export interface NpyHeader {
+    /** Data type descriptor (e.g., '<f8', '>i4') */
+    descr: string;
+    /** Whether array is Fortran-contiguous (column-major) */
+    fortran_order: boolean;
+    /** Array shape */
+    shape: number[];
+}
+/**
+ * Parsed NPY metadata including version
+ */
+export interface NpyMetadata {
+    version: NpyVersion;
+    header: NpyHeader;
+    /** Byte offset where data starts */
+    dataOffset: number;
+}
+/**
+ * Result of parsing an NPY header descriptor to our DType
+ */
+export interface DTypeParseResult {
+    dtype: DType;
+    /** Whether the data needs byte swapping (big-endian on little-endian or vice versa) */
+    needsByteSwap: boolean;
+    /** Element size in bytes */
+    itemsize: number;
+}
+/**
+ * All dtypes we support
+ */
+export declare const SUPPORTED_DTYPES: DType[];
+/**
+ * Detect system endianness
+ */
+export declare function isSystemLittleEndian(): boolean;
+/**
+ * DType to NPY descriptor mapping (for serialization)
+ * We always write little-endian
+ */
+export declare const DTYPE_TO_DESCR: Record<DType, string>;
+/**
+ * Unsupported dtype types (for error messages)
+ */
+export declare const UNSUPPORTED_DTYPE_PATTERNS: Record<string, string>;
+/**
+ * Parse a NumPy dtype descriptor string to our DType
+ *
+ * @param descr - NumPy descriptor like '<f8', '>i4', '|b1'
+ * @returns Parsed result with dtype and byte order info
+ * @throws Error if dtype is not supported
+ */
+export declare function parseDescriptor(descr: string): DTypeParseResult;
+/**
+ * Custom error for unsupported dtypes
+ */
+export declare class UnsupportedDTypeError extends Error {
+    constructor(message: string);
+}
+/**
+ * Custom error for invalid NPY format
+ */
+export declare class InvalidNpyError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=format.d.ts.map

package/dist/types/io/npy/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * NPY format reading and writing
+ */
+export { parseNpy, parseNpyHeader, parseNpyData } from './parser';
+export { serializeNpy } from './serializer';
+export { NPY_MAGIC, DTYPE_TO_DESCR, SUPPORTED_DTYPES, parseDescriptor, isSystemLittleEndian, UnsupportedDTypeError, InvalidNpyError, type NpyVersion, type NpyHeader, type NpyMetadata, type DTypeParseResult, } from './format';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/io/npy/parser.d.ts

@@ -0,0 +1,28 @@
+/**
+ * NPY file parser
+ *
+ * Parses NumPy .npy files (both v1 and v2/v3 formats) into NDArray objects.
+ */
+import { NDArray } from '../../core/ndarray';
+import { type NpyMetadata } from './format';
+/**
+ * Parse an NPY file from a Uint8Array or ArrayBuffer
+ *
+ * @param buffer - The NPY file contents
+ * @returns An NDArray containing the parsed data
+ * @throws InvalidNpyError if the file format is invalid
+ * @throws UnsupportedDTypeError if the dtype is not supported
+ */
+export declare function parseNpy(buffer: ArrayBuffer | Uint8Array): NDArray;
+/**
+ * Parse just the NPY header without reading the data
+ *
+ * @param bytes - The NPY file bytes
+ * @returns Parsed metadata including version, header, and data offset
+ */
+export declare function parseNpyHeader(bytes: Uint8Array): NpyMetadata;
+/**
+ * Parse the data section of an NPY file given parsed metadata
+ */
+export declare function parseNpyData(bytes: Uint8Array, metadata: NpyMetadata): NDArray;
+//# sourceMappingURL=parser.d.ts.map

package/dist/types/io/npy/serializer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * NPY file serializer
+ *
+ * Serializes NDArray objects to NumPy .npy format (v3.0).
+ * Always writes in little-endian, C-contiguous order.
+ *
+ * v3.0 is identical to v2.0 but allows UTF-8 in dtype descriptions.
+ */
+import { NDArray } from '../../core/ndarray';
+/**
+ * Serialize an NDArray to NPY format (v3.0)
+ *
+ * @param arr - The NDArray to serialize
+ * @returns A Uint8Array containing the NPY file data
+ */
+export declare function serializeNpy(arr: NDArray): Uint8Array;
+//# sourceMappingURL=serializer.d.ts.map

package/dist/types/io/npz/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * NPZ format reading and writing
+ */
+export { parseNpz, parseNpzSync, loadNpz, loadNpzSync, type NpzParseOptions, type NpzParseResult, } from './parser';
+export { serializeNpz, serializeNpzSync, type NpzSerializeOptions, type NpzArraysInput, } from './serializer';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/io/npz/parser.d.ts

@@ -0,0 +1,57 @@
+/**
+ * NPZ file parser
+ *
+ * NPZ is a ZIP archive containing multiple .npy files.
+ */
+import { NDArray } from '../../core/ndarray';
+/**
+ * Options for parsing NPZ files
+ */
+export interface NpzParseOptions {
+    /**
+     * If true, skip arrays with unsupported dtypes instead of throwing an error.
+     * Skipped arrays will not be included in the result.
+     * Default: false
+     */
+    force?: boolean;
+}
+/**
+ * Result of parsing an NPZ file
+ */
+export interface NpzParseResult {
+    /** Successfully parsed arrays */
+    arrays: Map<string, NDArray>;
+    /** Names of arrays that were skipped due to unsupported dtypes (only when force=true) */
+    skipped: string[];
+    /** Error messages for skipped arrays */
+    errors: Map<string, string>;
+}
+/**
+ * Parse an NPZ file from bytes
+ *
+ * @param buffer - The NPZ file contents
+ * @param options - Parse options
+ * @returns Promise resolving to parsed arrays
+ */
+export declare function parseNpz(buffer: ArrayBuffer | Uint8Array, options?: NpzParseOptions): Promise<NpzParseResult>;
+/**
+ * Synchronously parse an NPZ file (only works if not DEFLATE compressed)
+ *
+ * @param buffer - The NPZ file contents
+ * @param options - Parse options
+ * @returns Parsed arrays
+ */
+export declare function parseNpzSync(buffer: ArrayBuffer | Uint8Array, options?: NpzParseOptions): NpzParseResult;
+/**
+ * Convenience function to get arrays as a plain object
+ *
+ * @param buffer - The NPZ file contents
+ * @param options - Parse options
+ * @returns Promise resolving to object with array names as keys
+ */
+export declare function loadNpz(buffer: ArrayBuffer | Uint8Array, options?: NpzParseOptions): Promise<Record<string, NDArray>>;
+/**
+ * Synchronous version of loadNpz
+ */
+export declare function loadNpzSync(buffer: ArrayBuffer | Uint8Array, options?: NpzParseOptions): Record<string, NDArray>;
+//# sourceMappingURL=parser.d.ts.map

package/dist/types/io/npz/serializer.d.ts

@@ -0,0 +1,49 @@
+/**
+ * NPZ file serializer
+ *
+ * Serializes multiple NDArrays to NPZ format (ZIP archive of .npy files).
+ */
+import { NDArray } from '../../core/ndarray';
+/**
+ * Input type for arrays - supports:
+ * - Array of NDArrays (positional, named arr_0, arr_1, etc.)
+ * - Map of names to NDArrays
+ * - Object with names as keys
+ */
+export type NpzArraysInput = NDArray[] | Map<string, NDArray> | Record<string, NDArray>;
+/**
+ * Options for serializing NPZ files
+ */
+export interface NpzSerializeOptions {
+    /**
+     * Whether to compress the NPZ file using DEFLATE.
+     * Default: false (matches np.savez behavior; use true for np.savez_compressed behavior)
+     */
+    compress?: boolean;
+}
+/**
+ * Serialize multiple arrays to NPZ format
+ *
+ * @param arrays - Arrays to save. Can be:
+ *   - An array of NDArrays (named arr_0, arr_1, etc. like np.savez positional args)
+ *   - A Map of names to NDArrays
+ *   - An object with names as keys (like np.savez keyword args)
+ * @param options - Serialization options
+ * @returns Promise resolving to NPZ file as Uint8Array
+ *
+ * @example
+ * // Positional arrays (named arr_0, arr_1)
+ * await serializeNpz([arr1, arr2])
+ *
+ * // Named arrays
+ * await serializeNpz({ x: arr1, y: arr2 })
+ */
+export declare function serializeNpz(arrays: NpzArraysInput, options?: NpzSerializeOptions): Promise<Uint8Array>;
+/**
+ * Synchronously serialize multiple arrays to NPZ format (no compression)
+ *
+ * @param arrays - Arrays to save (same input types as serializeNpz)
+ * @returns NPZ file as Uint8Array
+ */
+export declare function serializeNpzSync(arrays: NpzArraysInput): Uint8Array;
+//# sourceMappingURL=serializer.d.ts.map

package/dist/types/io/zip/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Minimal ZIP file reading and writing
+ */
+export { readZip, readZipSync } from './reader';
+export { writeZip, writeZipSync, type ZipWriteOptions } from './writer';
+export { crc32, ZIP_STORED, ZIP_DEFLATED } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/io/zip/reader.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Minimal ZIP file reader
+ *
+ * Reads ZIP files with STORED or DEFLATE compression.
+ * Uses the Compression Streams API (built into modern browsers and Node.js 18+).
+ */
+/**
+ * Read a ZIP file and return its entries
+ *
+ * @param buffer - ZIP file contents
+ * @returns Map of file names to their uncompressed data
+ */
+export declare function readZip(buffer: ArrayBuffer | Uint8Array): Promise<Map<string, Uint8Array>>;
+/**
+ * Synchronously read a ZIP file (only works for STORED entries)
+ *
+ * @param buffer - ZIP file contents
+ * @returns Map of file names to their uncompressed data
+ * @throws Error if any entry uses compression
+ */
+export declare function readZipSync(buffer: ArrayBuffer | Uint8Array): Map<string, Uint8Array>;
+//# sourceMappingURL=reader.d.ts.map

package/dist/types/io/zip/types.d.ts

@@ -0,0 +1,59 @@
+/**
+ * ZIP file format types and constants
+ */
+/**
+ * ZIP local file header signature
+ */
+export declare const ZIP_LOCAL_SIGNATURE = 67324752;
+/**
+ * ZIP central directory header signature
+ */
+export declare const ZIP_CENTRAL_SIGNATURE = 33639248;
+/**
+ * ZIP end of central directory signature
+ */
+export declare const ZIP_END_SIGNATURE = 101010256;
+/**
+ * Compression methods
+ */
+export declare const ZIP_STORED = 0;
+export declare const ZIP_DEFLATED = 8;
+/**
+ * Entry in a ZIP file
+ */
+export interface ZipEntry {
+    /** File name */
+    name: string;
+    /** Uncompressed data */
+    data: Uint8Array;
+    /** Compression method used */
+    compressionMethod: number;
+    /** CRC-32 checksum */
+    crc32: number;
+    /** Compressed size */
+    compressedSize: number;
+    /** Uncompressed size */
+    uncompressedSize: number;
+}
+/**
+ * Raw entry as read from ZIP (before decompression)
+ */
+export interface RawZipEntry {
+    /** File name */
+    name: string;
+    /** Compressed data */
+    compressedData: Uint8Array;
+    /** Compression method */
+    compressionMethod: number;
+    /** CRC-32 checksum */
+    crc32: number;
+    /** Compressed size */
+    compressedSize: number;
+    /** Uncompressed size */
+    uncompressedSize: number;
+}
+/**
+ * Calculate CRC-32 checksum
+ */
+export declare function crc32(data: Uint8Array): number;
+//# sourceMappingURL=types.d.ts.map

package/dist/types/io/zip/writer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Minimal ZIP file writer
+ *
+ * Creates ZIP files with optional DEFLATE compression.
+ * Uses the Compression Streams API (built into modern browsers and Node.js 18+).
+ */
+/**
+ * Options for writing a ZIP file
+ */
+export interface ZipWriteOptions {
+    /** Whether to compress files (default: false for NPZ compatibility) */
+    compress?: boolean;
+}
+/**
+ * Create a ZIP file from a map of file names to data
+ *
+ * @param files - Map of file names to their data
+ * @param options - Write options
+ * @returns ZIP file as Uint8Array
+ */
+export declare function writeZip(files: Map<string, Uint8Array>, options?: ZipWriteOptions): Promise<Uint8Array>;
+/**
+ * Create a ZIP file synchronously (no compression)
+ *
+ * @param files - Map of file names to their data
+ * @returns ZIP file as Uint8Array
+ */
+export declare function writeZipSync(files: Map<string, Uint8Array>): Uint8Array;
+//# sourceMappingURL=writer.d.ts.map

package/dist/types/node.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Node.js-specific entry point for numpy-ts
+ *
+ * This module provides file system operations for saving and loading NPY/NPZ files,
+ * plus all core numpy-ts functionality in a single import.
+ *
+ * Usage:
+ *   import * as np from 'numpy-ts/node';
+ *   // Has everything from numpy-ts + file I/O
+ *   const arr = await np.loadNpy('data.npy');
+ *   await np.saveNpz('output.npz', { x: arr });
+ *
+ * For browser usage, use the main entry point (no file I/O).
+ */
+import { NDArray } from './core/ndarray';
+import { type NpzParseOptions, type NpzParseResult } from './io/npz/parser';
+import { type NpzSerializeOptions, type NpzArraysInput } from './io/npz/serializer';
+export * from './index';
+export * from './io';
+/**
+ * Options for loading NPY/NPZ files
+ */
+export interface LoadOptions extends NpzParseOptions {
+    /**
+     * If true, allow loading .npy files.
+     * Default: true
+     */
+    allowNpy?: boolean;
+}
+/**
+ * Options for saving NPZ files
+ */
+export interface SaveNpzOptions extends NpzSerializeOptions {
+}
+/**
+ * Load an NDArray from a .npy file
+ *
+ * @param path - Path to the .npy file
+ * @returns The loaded NDArray
+ */
+export declare function loadNpy(path: string): Promise<NDArray>;
+/**
+ * Synchronously load an NDArray from a .npy file
+ *
+ * @param path - Path to the .npy file
+ * @returns The loaded NDArray
+ */
+export declare function loadNpySync(path: string): NDArray;
+/**
+ * Save an NDArray to a .npy file
+ *
+ * @param path - Path to save the .npy file
+ * @param arr - The NDArray to save
+ */
+export declare function saveNpy(path: string, arr: NDArray): Promise<void>;
+/**
+ * Synchronously save an NDArray to a .npy file
+ *
+ * @param path - Path to save the .npy file
+ * @param arr - The NDArray to save
+ */
+export declare function saveNpySync(path: string, arr: NDArray): void;
+/**
+ * Load arrays from a .npz file
+ *
+ * @param path - Path to the .npz file
+ * @param options - Load options
+ * @returns Object with array names as keys
+ */
+export declare function loadNpzFile(path: string, options?: NpzParseOptions): Promise<NpzParseResult>;
+/**
+ * Synchronously load arrays from a .npz file
+ *
+ * Note: Only works if the NPZ file is not DEFLATE compressed.
+ *
+ * @param path - Path to the .npz file
+ * @param options - Load options
+ * @returns Object with array names as keys
+ */
+export declare function loadNpzFileSync(path: string, options?: NpzParseOptions): NpzParseResult;
+/**
+ * Save arrays to a .npz file
+ *
+ * @param path - Path to save the .npz file
+ * @param arrays - Arrays to save:
+ *   - Array of NDArrays (positional, named arr_0, arr_1, etc.)
+ *   - Map of names to NDArrays
+ *   - Object with names as keys
+ * @param options - Save options
+ */
+export declare function saveNpz(path: string, arrays: NpzArraysInput, options?: SaveNpzOptions): Promise<void>;
+/**
+ * Synchronously save arrays to a .npz file (no compression)
+ *
+ * @param path - Path to save the .npz file
+ * @param arrays - Arrays to save (same types as saveNpz)
+ */
+export declare function saveNpzSync(path: string, arrays: NpzArraysInput): void;
+/**
+ * Load an array or arrays from a .npy or .npz file
+ *
+ * This is a convenience function that auto-detects the file format based on extension.
+ *
+ * @param path - Path to the file
+ * @param options - Load options
+ * @returns NDArray for .npy files, or NpzParseResult for .npz files
+ */
+export declare function load(path: string, options?: LoadOptions): Promise<NDArray | NpzParseResult>;
+/**
+ * Synchronously load an array or arrays from a .npy or .npz file
+ *
+ * @param path - Path to the file
+ * @param options - Load options
+ * @returns NDArray for .npy files, or NpzParseResult for .npz files
+ */
+export declare function loadSync(path: string, options?: LoadOptions): NDArray | NpzParseResult;
+/**
+ * Save an array to a .npy file
+ *
+ * @param path - Path to save the file (should end with .npy)
+ * @param arr - The NDArray to save
+ */
+export declare function save(path: string, arr: NDArray): Promise<void>;
+/**
+ * Synchronously save an array to a .npy file
+ *
+ * @param path - Path to save the file (should end with .npy)
+ * @param arr - The NDArray to save
+ */
+export declare function saveSync(path: string, arr: NDArray): void;
+/**
+ * Save multiple arrays to a .npz file (like np.savez)
+ *
+ * @param path - Path to save the .npz file
+ * @param arrays - Arrays to save:
+ *   - Array of NDArrays: named arr_0, arr_1, etc. (like np.savez positional args)
+ *   - Object/Map with names as keys (like np.savez keyword args)
+ *
+ * @example
+ * // Positional arrays
+ * await savez('data.npz', [arr1, arr2])  // saved as arr_0, arr_1
+ *
+ * // Named arrays
+ * await savez('data.npz', { x: arr1, y: arr2 })
+ */
+export declare function savez(path: string, arrays: NpzArraysInput): Promise<void>;
+/**
+ * Save multiple arrays to a compressed .npz file (like np.savez_compressed)
+ *
+ * @param path - Path to save the .npz file
+ * @param arrays - Arrays to save (same input types as savez)
+ */
+export declare function savez_compressed(path: string, arrays: NpzArraysInput): Promise<void>;
+//# sourceMappingURL=node.d.ts.map

package/dist/types/ops/advanced.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Advanced array operations
+ *
+ * Broadcasting, indexing, and comparison functions.
+ * @module ops/advanced
+ */
+import { ArrayStorage } from '../core/storage';
+import { broadcastShapes } from '../core/broadcasting';
+/**
+ * Broadcast an array to a given shape
+ * Returns a read-only view on the original array
+ */
+export declare function broadcast_to(storage: ArrayStorage, targetShape: number[]): ArrayStorage;
+/**
+ * Broadcast multiple arrays to a common shape
+ * Returns views on the original arrays
+ */
+export declare function broadcast_arrays(storages: ArrayStorage[]): ArrayStorage[];
+/**
+ * Compute the broadcast shape for multiple shapes
+ * Re-export from core/broadcasting for convenience
+ */
+export { broadcastShapes as broadcast_shapes };
+/**
+ * Take elements from an array along an axis
+ */
+export declare function take(storage: ArrayStorage, indices: number[], axis?: number): ArrayStorage;
+/**
+ * Put values at specified indices (modifies array in-place)
+ */
+export declare function put(storage: ArrayStorage, indices: number[], values: ArrayStorage | number | bigint): void;
+/**
+ * Construct array from index array and choices
+ */
+export declare function choose(indexStorage: ArrayStorage, choices: ArrayStorage[]): ArrayStorage;
+/**
+ * Check if two arrays are element-wise equal
+ */
+export declare function array_equal(a: ArrayStorage, b: ArrayStorage, equal_nan?: boolean): boolean;
+//# sourceMappingURL=advanced.d.ts.map

package/dist/types/ops/arithmetic.d.ts

@@ -105,4 +105,58 @@ export declare function positive(a: ArrayStorage): ArrayStorage;
  * @returns Result storage with reciprocal values
  */
 export declare function reciprocal(a: ArrayStorage): ArrayStorage;
+/**
+ * Cube root of each element
+ * NumPy behavior: Promotes integer types to float64
+ *
+ * @param a - Input array storage
+ * @returns Result storage with cube root values
+ */
+export declare function cbrt(a: ArrayStorage): ArrayStorage;
+/**
+ * Absolute value of each element, returning float
+ * NumPy behavior: fabs always returns floating point
+ *
+ * @param a - Input array storage
+ * @returns Result storage with absolute values as float
+ */
+export declare function fabs(a: ArrayStorage): ArrayStorage;
+/**
+ * Returns both quotient and remainder (floor divide and modulo)
+ * NumPy behavior: divmod(a, b) = (floor_divide(a, b), mod(a, b))
+ *
+ * @param a - Dividend array storage
+ * @param b - Divisor (array storage or scalar)
+ * @returns Tuple of [quotient, remainder] storages
+ */
+export declare function divmod(a: ArrayStorage, b: ArrayStorage | number): [ArrayStorage, ArrayStorage];
+/**
+ * Element-wise square of each element
+ * NumPy behavior: x**2
+ *
+ * @param a - Input array storage
+ * @returns Result storage with squared values
+ */
+export declare function square(a: ArrayStorage): ArrayStorage;
+/**
+ * Remainder of division (same as mod)
+ * NumPy behavior: Same as mod, alias for compatibility
+ *
+ * @param a - Dividend array storage
+ * @param b - Divisor (array storage or scalar)
+ * @returns Result storage with remainder values
+ */
+export declare function remainder(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Heaviside step function
+ * NumPy behavior:
+ *   heaviside(x1, x2) = 0 if x1 < 0
+ *                     = x2 if x1 == 0
+ *                     = 1 if x1 > 0
+ *
+ * @param x1 - Input array storage
+ * @param x2 - Value to use when x1 == 0 (array storage or scalar)
+ * @returns Result storage with heaviside values
+ */
+export declare function heaviside(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
 //# sourceMappingURL=arithmetic.d.ts.map