Miscellaneous Utilities

apply_along_axis

Apply a function to 1-D slices of an array along the given axis. The function is called once for each slice, and the results are assembled into an output array. Supports arrays of any dimensionality. For ND arrays, the function iterates over all combinations of indices on dimensions other than axis. Any trailing arguments are forwarded to each invocation of func1d, matching NumPy’s np.apply_along_axis(func1d, axis, arr, *args). Existing 3-argument calls behave identically.

function apply_along_axis(
  func1d: (arr: NDArray, ...args: unknown[]) => NDArray | number,
  axis: number,
  arr: ArrayLike,
  ...args: unknown[]
): NDArray

|-|-|-|-|

Parameter	Type	Default	Description
`func1d`	`(arr: NDArray, ...args) => number \| NDArray`	—	Function that operates on a 1-D array and returns a scalar or 1-D array. Receives any trailing `...args`.
`axis`	`number`	—	Axis along which to apply `func1d`.
`arr`	`ArrayLike`	—	Input array.
`...args`	`any[]`	—	Additional arguments forwarded to each call of `func1d`.

Returns: NDArray — The result of applying func1d along the specified axis.

Changed in v1.7.0: func1d now receives a view of each slice rather than a copy, matching NumPy. A callback that mutates its argument in place will write through to arr. If your callback modifies the slice it is handed, copy it first:

apply_along_axis((s) => { const t = s.copy(); t.set(0, 0); return t; }, 0, a);

import { array, apply_along_axis, sort } from 'numpy-ts';

const a = array([[3, 1, 2], [6, 4, 5]]);

// Sort each row
const sorted = apply_along_axis(
  (row) => sort(row),
  1,
  a
);
// array([[1, 2, 3],
//        [4, 5, 6]])

// Sum each column (returns scalars)
const colSums = apply_along_axis(
  (col) => col.toArray().reduce((a, b) => a + b, 0),
  0,
  a
);
// array([9, 5, 7])

// Sum along axis 2 of a 3-D array
const b = np.ones([2, 3, 4]);
const result = apply_along_axis(
  (row) => row.sum(),
  2,
  b
);
console.log(result.shape);  // [2, 3]

// Forward extra args to func1d (here: a scalar multiplier).
const scaled = apply_along_axis(
  (row, k) => row.multiply(k),
  1,
  a,
  3
);
// array([[ 9,  3,  6],
//        [18, 12, 15]])

apply_over_axes

Apply a function repeatedly over multiple axes. After each application, the result is kept with the reduced axis preserved as a size-1 dimension, so subsequent axes remain valid.

function apply_over_axes(
  func: (a: NDArray, axis: number) => NDArray,
  a: ArrayLike,
  axes: number[]
): NDArray

Parameter	Type	Default	Description
`func`	`(a: NDArray, axis: number) => NDArray`	—	Function that takes an array and an axis, returning an array with that axis reduced to size 1.
`a`	`ArrayLike`	—	Input array.
`axes`	`number[]`	—	Axes over which to apply `func`, in order.

Returns: NDArray — The result of applying func over all specified axes.

import { array, apply_over_axes, sum } from 'numpy-ts';

const a = array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]);
// shape: [2, 2, 2]

// Sum over axes 0 and 2
const result = apply_over_axes(
  (arr, axis) => sum(arr, axis, true),
  a,
  [0, 2]
);
// shape: [1, 2, 1]
// array([[[10], [22]]])

shares_memory

Determine whether two arrays share the same underlying data buffer. Returns true only when the arrays definitely reference overlapping memory.

function shares_memory(a: ArrayLike, b: ArrayLike): boolean

Parameter	Type	Default	Description
`a`	`ArrayLike`	—	First input array.
`b`	`ArrayLike`	—	Second input array.

Returns: boolean — true if both arrays share memory.

import { array, reshape, copy, shares_memory } from 'numpy-ts';

const a = array([1, 2, 3, 4]);
const b = reshape(a, [2, 2]);   // view
const c = copy(a);              // independent copy

shares_memory(a, b);  // true  -- b is a view of a
shares_memory(a, c);  // false -- c is a copy

may_share_memory

Determine whether two arrays might share memory. This is a less strict check than shares_memory — it may return true even when the arrays do not actually overlap, but it never returns false when they do.

function may_share_memory(a: ArrayLike, b: ArrayLike): boolean

Parameter	Type	Default	Description
`a`	`ArrayLike`	—	First input array.
`b`	`ArrayLike`	—	Second input array.

Returns: boolean — true if the arrays might share memory.

import { array, reshape, copy, may_share_memory } from 'numpy-ts';

const a = array([1, 2, 3, 4, 5, 6]);
const b = reshape(a, [2, 3]);

may_share_memory(a, b);  // true
may_share_memory(a, copy(a));  // false

ndim

Return the number of dimensions of an array.

function ndim(a: ArrayLike | number | bigint | boolean): number

Parameter	Type	Default	Description
`a`	`ArrayLike`	—	Input array or array-like.

Returns: number — The number of dimensions (axes).

import { array, ndim } from 'numpy-ts';

ndim(array([1, 2, 3]));             // 1
ndim(array([[1, 2], [3, 4]]));      // 2
ndim(array([[[1]]]));               // 3

shape

Return the shape of an array as a number array.

function shape(a: ArrayLike | number | bigint | boolean): number[] | readonly number[]

Parameter	Type	Default	Description
`a`	`ArrayLike`	—	Input array or array-like.

Returns: number[] — The dimensions of the array.

import { array, zeros, shape } from 'numpy-ts';

shape(array([1, 2, 3]));             // [3]
shape(array([[1, 2], [3, 4]]));      // [2, 2]
shape(zeros([3, 4, 5]));             // [3, 4, 5]

size

Return the total number of elements in an array.

function size(a: ArrayLike | number | bigint | boolean): number

Parameter	Type	Default	Description
`a`	`ArrayLike`	—	Input array or array-like.

Returns: number — The total number of elements (product of shape dimensions).

import { array, zeros, size } from 'numpy-ts';

size(array([1, 2, 3]));            // 3
size(array([[1, 2], [3, 4]]));     // 4
size(zeros([3, 4, 5]));            // 60

geterr

Get the current error handling settings for floating-point operations.

function geterr(): FloatErrorState

Returns: object — An object with keys divide, over, under, and invalid, each set to one of 'warn', 'raise', 'ignore', or 'print'.

import { geterr } from 'numpy-ts';

const settings = geterr();
console.log(settings);
// { divide: 'warn', over: 'warn', under: 'ignore', invalid: 'warn' }

seterr

Set how floating-point errors are handled. Returns the previous settings so you can restore them later.

function seterr(
  all?: ErrorMode,
  divide?: ErrorMode,
  over?: ErrorMode,
  under?: ErrorMode,
  invalid?: ErrorMode
): FloatErrorState

Parameter	Type	Default	Description
`all`	`ErrorMode`	`undefined`	Default mode applied to all error categories unless overridden by specific args.
`divide`	`ErrorMode`	`undefined`	Division-by-zero handling mode.
`over`	`ErrorMode`	`undefined`	Overflow handling mode.
`under`	`ErrorMode`	`undefined`	Underflow handling mode.
`invalid`	`ErrorMode`	`undefined`	Invalid operation handling mode.

Returns: FloatErrorState — The previous error handling settings.

import { seterr, geterr } from 'numpy-ts';

// Suppress all warnings
const old = seterr(undefined, 'ignore', 'ignore');

// ... perform operations that may divide by zero ...

// Restore previous settings
seterr(undefined, old.divide, old.over, old.under, old.invalid);

item

Get a single scalar element from an array.

function item(a: ArrayLike, ...args: number[]): number | bigint | boolean | Complex

tolist

Convert an array to nested JavaScript arrays (or a scalar for 0-D arrays).

function tolist(a: ArrayLike): unknown

tobytes

Return the raw bytes of an array in C-order by default.

function tobytes(a: ArrayLike, order?: 'C' | 'F'): Uint8Array

byteswap

Swap the byte order of each array element.

function byteswap(a: ArrayLike, inplace?: boolean): NDArray

view

Create a view of an array (same dtype view currently supported).

function view(a: ArrayLike, dtype?: DType): NDArray

tofile

Write an array to a file (Node.js-oriented API; see note in implementation for environment limits).

function tofile(_a: ArrayLike, _file: string, _sep?: string, _format?: string): void

fill

Fill an array in place with a scalar value.

function fill(a: NDArray, value: number | bigint | boolean | Complex): void

configureWasm

Set the size of the WASM linear memory before it is allocated. Raise maxMemory when a workload exhausts the heap, or lower it in memory-constrained environments such as a serverless runtime.

function configureWasm(options: ConfigureWasmOptions): void

Name	Type	Default	Description
`options.maxMemory`	`number`	`268435456` (256 MiB)	Total WASM linear memory, in bytes. Must be positive.
`options.scratchSize`	`number`	`maxMemory / 16`	Scratch region for temporary kernel buffers, in bytes.

Returns: void

This must be called before any array operation. WASM memory is allocated lazily on first use, and once allocated it cannot be resized — calling configureWasm afterwards throws.

import * as np from 'numpy-ts';

// Before touching any array API
np.configureWasm({ maxMemory: 1024 * 1024 * 1024 }); // 1 GiB

const a = np.zeros([10000, 10000]);

wasmFreeBytes

Report how many bytes remain available in the WASM heap. Useful for spotting a leak in a long-running process, or for sizing a batch before allocating it.

function wasmFreeBytes(): number

Returns: number — Free bytes in the WASM heap. Initializes the heap if it has not been allocated yet, so calling this counts as first use for the purposes of configureWasm.

import * as np from 'numpy-ts';

const before = np.wasmFreeBytes();
const a = np.zeros([1000, 1000]);
console.log(before - np.wasmFreeBytes()); // bytes consumed by `a`

Overview

NDArray

Array Creation

Math

Array Manipulation

Reductions & Statistics

Linear Algebra

Logic & Comparison

Sorting & Searching

Set Operations

Bitwise

Indexing

Gradient & Differences

Polynomials

Random (np.random)

FFT (np.fft)

I/O

Utilities

Miscellaneous Utilities

apply_along_axis

apply_over_axes

shares_memory

may_share_memory

ndim

shape

size

geterr

seterr

item

tolist

tobytes

byteswap

view

tofile

fill

configureWasm

wasmFreeBytes

​apply_along_axis

​apply_over_axes

​shares_memory

​may_share_memory

​ndim

​shape

​size

​geterr

​seterr

​item

​tolist

​tobytes

​byteswap

​view

​tofile

​fill

​configureWasm

​wasmFreeBytes

apply_along_axis

apply_over_axes

shares_memory

may_share_memory

ndim

shape

size

geterr

seterr

item

tolist

tobytes

byteswap

view

tofile

fill

configureWasm

wasmFreeBytes