Function np

  • np(template, ...variables): any

  • Parser and main namespace for the ndarray-js package.

    Parameters

    Returns any

Attributes

ndim shape size

Axes

atleast_1d atleast_2d atleast_3d expand_dims matrix_transpose moveaxis permute_dims rollaxis squeeze swapaxes

Binary operators

add arctan2 atan2 bitwise_and bitwise_count bitwise_invert bitwise_left_shift bitwise_or bitwise_right_shift bitwise_shift_left bitwise_shift_right bitwise_xor copysign divide divide_int divmod equal float_power floor_divide fmax fmin fmod gcd greater greater_equal heaviside hypot lcm ldexp left_shift less less_equal logaddexp logaddexp2 logical_and logical_or logical_xor maximum minimum mod multiply nextafter not_equal pow power remainder right_shift subtract true_divide

Broadcasting

broadcast broadcast_arrays broadcast_shapes broadcast_to

Casting and reshaping

array asanyarray asarray astype copy copyto fromlist ravel require reshape tolist

Comparison

allclose array_equal array_equiv isclose

Constructors

arange asarray_chkfinite ascontiguousarray asfortranarray asmatrix bmat diag diagflat empty empty_like eye from_dlpack frombuffer fromfunction fromiter full full_like geomspace identity linspace logspace mat meshgrid mgrid ogrid ones ones_like rec tri tril triu vander zeros zeros_like

Cumulative

cumprod cumsum cumulative_prod cumulative_sum nancumprod nancumsum

Differences

diff ediff1d gradient

Elementwise operators

abs acos acosh angle around asin asinh atan atanh bitwise_not cbrt ceil clip conj conjugate cos cosh deg2rad degrees exp exp2 expm1 fix floor frexp i0 imag invert iscomplex isfinite isinf isnan isneginf isposinf isreal log log10 log1p log2 logical_not modf nan_to_num negative positive rad2deg radians real real_if_close reciprocal rint round sign signbit sin sinc sinh spacing sqrt square tan tanh trunc valueOf

Error handling

exceptions geterr geterrcall seterr seterrcall errstate

FFT

fft

Formatting

array2string array_repr array_str base_repr binary_repr format_float_positional format_float_scientific get_printoptions packbits set_printoptions unpackbits printoptions

Functional

apply_over_axes frompyfunc piecewise vectorize

Histograms

bincount digitize histogram histogram2d histogram_bin_edges histogramdd

Index generators

diag_indices diag_indices_from indices ix_ mask_indices ravel_multi_index tril_indices tril_indices_from triu_indices triu_indices_from unravel_index

Index tricks

c_ index_exp r_ s_

Indexing

choose compress diagonal fill_diagonal place put put_along_axis putmask select take take_along_axis

Input and output

fromfile fromregex fromstring genfromtxt lib load loadtxt memmap save savetxt savez savez_compressed

Inserting and deleting

append delete insert resize trim_zeros

Iteration

flatiter iterable ndenumerate nested_iters ndindex nditer

Joining

block column_stack concat dstack hstack vstack

Linear algebra

dot einsum inner kron linalg matmul matvec outer tensordot trace vdot vecdot vecmat einsum_path

Main

NDArray modules

Math

convolve cross emath interp trapezoid unwrap

Math constants

e euler_gamma inf nan newaxis pi

Memory

may_share_memory shares_memory

Modules

random

Other

DataSource False_ True_ absolute amax amin arccos arccosh arcsin arcsinh arctan arctanh assign busday_count busday_offset busdaycalendar datetime_as_string datetime_data fabs is_busday isnat little_endian ndarray isfortran

Padding

pad

Polynomials

poly poly1d polyadd polyder polydiv polyfit polyint polymul polynomial polysub polyval roots

Reducers

all any argmax argmin count_nonzero len max mean min nanargmax nanargmin nanmax nanmean nanmin nanprod nanstd nansum nanvar norm prod product ptp std sum var

Reordering

flip fliplr flipud roll rot90

Repeating

repeat tile

Searching

argwhere extract flatnonzero nonzero searchsorted where

Sets

group_by intersect1d isin setdiff1d setxor1d union1d unique unique_all unique_counts unique_inverse unique_values

Settings

get_include getbufsize info setbufsize show_config show_runtime

Sorting

argpartition argsort lexsort partition sort sort_complex

Splitting

array_split dsplit hsplit split unstack vsplit

Statistics

average corrcoef correlate cov median nanmedian nanpercentile nanquantile percentile quantile

Strings

char strings

Testing

testing

Transformations

apply_along_axis concatenate stack transpose

Types

Complex can_cast isdtype issubdtype mintypecode promote_types typename common_type complex dtype finfo iinfo iscomplexobj isrealobj isscalar min_scalar_type result_type

Windows

bartlett blackman hamming hanning kaiser

Attributes

ndim

ndim: ((a, ...rest) => number)

Type declaration

    • (a, ...rest): number

    • Parameters

      Returns number

shape

shape: ((a, ...rest) => number)

Type declaration

    • (a, ...rest): number

    • Parameters

      Returns number

size

size: ((a, ...rest) => number)

Type declaration

    • (a, ...rest): number

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            axis: number;
        }
      • Rest ...rest: [axis: number | {
            a: ArrOrAny;
        } & {
            axis: number;
        }]

      Returns number

Axes

atleast_1d

atleast_1d: ((...args) => any) & ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

atleast_2d

atleast_2d: ((...args) => any) & ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

atleast_3d

atleast_3d: ((...args) => any) & ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

expand_dims

expand_dims: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            axis: number | number[];
        }
      • Rest ...rest: [axis: number | number[] | {
            a: ArrOrAny;
        } & {
            axis: number | number[];
        }]

      Returns NDArray

matrix_transpose

matrix_transpose: ((a, ...rest) => NDArray)

Type declaration

moveaxis

moveaxis: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            source: number | number[];
        } & {
            destination: number | number[];
        }
      • Rest ...rest: [source: number | number[] | {
            a: ArrOrAny;
        } & {
            source: number | number[];
        } & {
            destination: number | number[];
        }, destination: number | number[] | {
            a: ArrOrAny;
        } & {
            source: number | number[];
        } & {
            destination: number | number[];
        }]

      Returns NDArray

permute_dims

permute_dims: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            axes: number[];
        }
      • Rest ...rest: [axes: number[] | {
            a: ArrOrAny;
        } & {
            axes: number[];
        }]

      Returns NDArray

rollaxis

rollaxis: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            start: number;
        }
      • Rest ...rest: [axis: number | {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            start: number;
        }, start: number | {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            start: number;
        }]

      Returns NDArray

squeeze

squeeze: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            axis: number | number[];
        }
      • Rest ...rest: [axis: number | number[] | {
            a: ArrOrAny;
        } & {
            axis: number | number[];
        }]

      Returns NDArray

swapaxes

swapaxes: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            axis1: number;
        } & {
            axis2: number;
        }
      • Rest ...rest: [axisA: number | {
            a: ArrOrAny;
        } & {
            axis1: number;
        } & {
            axis2: number;
        }, axisB: number | {
            a: ArrOrAny;
        } & {
            axis1: number;
        } & {
            axis2: number;
        }]

      Returns NDArray

Binary operators

add

add: Wrapper

arctan2

arctan2: Wrapper

atan2

atan2: Wrapper

bitwise_and

bitwise_and: Wrapper

bitwise_count

bitwise_count: ((a, ...rest) => NDArray)

Type declaration

bitwise_invert

bitwise_invert: Wrapper

bitwise_left_shift

bitwise_left_shift: Wrapper

bitwise_or

bitwise_or: Wrapper

bitwise_right_shift

bitwise_right_shift: Wrapper

bitwise_shift_left

bitwise_shift_left: Wrapper

bitwise_shift_right

bitwise_shift_right: Wrapper

bitwise_xor

bitwise_xor: Wrapper

copysign

copysign: Wrapper

divide

divide: Wrapper

divide_int

divide_int: Wrapper

divmod

divmod: ((x, y) => NDArray[])

Type declaration

equal

equal: Wrapper

float_power

float_power: Wrapper

floor_divide

floor_divide: Wrapper

fmax

fmax: Wrapper

fmin

fmin: Wrapper

fmod

fmod: Wrapper

gcd

gcd: Wrapper

greater

greater: Wrapper

greater_equal

greater_equal: Wrapper

heaviside

heaviside: Wrapper

hypot

hypot: Wrapper

lcm

lcm: Wrapper

ldexp

ldexp: Wrapper

left_shift

left_shift: Wrapper

less

less: Wrapper

less_equal

less_equal: Wrapper

logaddexp

logaddexp: Wrapper

logaddexp2

logaddexp2: Wrapper

logical_and

logical_and: Wrapper

logical_or

logical_or: Wrapper

logical_xor

logical_xor: Wrapper

maximum

maximum: Wrapper

minimum

minimum: Wrapper

mod

mod: Wrapper

multiply

multiply: Wrapper

nextafter

nextafter: Wrapper

not_equal

not_equal: Wrapper

pow

pow: Wrapper

power

power: Wrapper

remainder

remainder: Wrapper

right_shift

right_shift: Wrapper

subtract

subtract: Wrapper

true_divide

true_divide: Wrapper

Broadcasting

broadcast

broadcast: ((...args) => any) & ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

broadcast_arrays

broadcast_arrays: ((...args) => any) & ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

broadcast_shapes

broadcast_shapes: ((...shapes) => number[])

Type declaration

    • (...shapes): number[]

    • Parameters

      • Rest ...shapes: (number | number[])[]

      Returns number[]

broadcast_to

broadcast_to: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            array: ArrOrAny;
        } & {
            shape: number | number[];
        }
      • Rest ...rest: [shape: number | number[] | {
            array: ArrOrAny;
        } & {
            shape: number | number[];
        }]

      Returns NDArray

Casting and reshaping

array

array: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            object: ArrOrAny;
        } & {
            dtype: DType;
        } & {
            copy: boolean;
        } & {
            ndmin: number;
        }
      • Rest ...rest: [dtype: DType | {
            object: ArrOrAny;
        } & {
            dtype: DType;
        } & {
            copy: boolean;
        } & {
            ndmin: number;
        }, copy: boolean | {
            object: ArrOrAny;
        } & {
            dtype: DType;
        } & {
            copy: boolean;
        } & {
            ndmin: number;
        }, ndmin: number | {
            object: ArrOrAny;
        } & {
            dtype: DType;
        } & {
            copy: boolean;
        } & {
            ndmin: number;
        }]

      Returns NDArray

asanyarray

asanyarray: ((a, ...rest) => NDArray)

Type declaration

asarray

asarray: ((a, ...rest) => NDArray)

Type declaration

astype

astype: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            x: ArrOrAny;
        } & {
            dtype: DType;
        } & {
            copy: boolean;
        }
      • Rest ...rest: [dtype: DType | {
            x: ArrOrAny;
        } & {
            dtype: DType;
        } & {
            copy: boolean;
        }, copy: boolean | {
            x: ArrOrAny;
        } & {
            dtype: DType;
        } & {
            copy: boolean;
        }]

      Returns NDArray

copy

copy: ((a, ...rest) => NDArray)

Type declaration

copyto

copyto: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            dst: ArrOrAny;
        } & {
            src: ArrOrAny;
        } & {
            casting: string;
        } & {
            where: boolean | NDArray;
        }
      • Rest ...rest: [src: ArrOrAny | {
            dst: ArrOrAny;
        } & {
            src: ArrOrAny;
        } & {
            casting: string;
        } & {
            where: boolean | NDArray;
        }, casting: string | {
            dst: ArrOrAny;
        } & {
            src: ArrOrAny;
        } & {
            casting: string;
        } & {
            where: boolean | NDArray;
        }, where: boolean | NDArray | {
            dst: ArrOrAny;
        } & {
            src: ArrOrAny;
        } & {
            casting: string;
        } & {
            where: boolean | NDArray;
        }]

      Returns NDArray

fromlist

fromlist: ((arr, dtype?) => NDArray)

Type declaration

ravel

ravel: ((a, ...rest) => NDArray)

Type declaration

require

require: ((a, ...rest) => any)

Type declaration

reshape

reshape: ((a, ...rest) => NDArray) & ((...args) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            shape: any[];
        }
      • Rest ...rest: [shape: any[] | {
            a: ArrOrAny;
        } & {
            shape: any[];
        }]

      Returns NDArray

Type declaration

tolist

Comparison

allclose

allclose: ((a, ...rest) => boolean)

Type declaration

    • (a, ...rest): boolean

    • Parameters

      • a: ArrayOrConstant | {
            a: ArrayOrConstant;
        } & {
            b: ArrayOrConstant;
        } & {
            rtol: number;
        } & {
            atol: number;
        } & {
            equal_nan: boolean;
        }
      • Rest ...rest: [b: ArrayOrConstant | {
            a: ArrayOrConstant;
        } & {
            b: ArrayOrConstant;
        } & {
            rtol: number;
        } & {
            atol: number;
        } & {
            equal_nan: boolean;
        }, rtol: number | {
            a: ArrayOrConstant;
        } & {
            b: ArrayOrConstant;
        } & {
            rtol: number;
        } & {
            atol: number;
        } & {
            equal_nan: boolean;
        }, atol: number | {
            a: ArrayOrConstant;
        } & {
            b: ArrayOrConstant;
        } & {
            rtol: number;
        } & {
            atol: number;
        } & {
            equal_nan: boolean;
        }, equal_nan: boolean | {
            a: ArrayOrConstant;
        } & {
            b: ArrayOrConstant;
        } & {
            rtol: number;
        } & {
            atol: number;
        } & {
            equal_nan: boolean;
        }]

      Returns boolean

array_equal

array_equal: ((a, ...rest) => boolean)

Type declaration

array_equiv

array_equiv: ((a, ...rest) => boolean)

Type declaration

isclose

isclose: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrayOrConstant | {
            a: ArrayOrConstant;
        } & {
            b: ArrayOrConstant;
        } & {
            rtol: number;
        } & {
            atol: number;
        } & {
            equal_nan: boolean;
        }
      • Rest ...rest: [b: ArrayOrConstant | {
            a: ArrayOrConstant;
        } & {
            b: ArrayOrConstant;
        } & {
            rtol: number;
        } & {
            atol: number;
        } & {
            equal_nan: boolean;
        }, rtol: number | {
            a: ArrayOrConstant;
        } & {
            b: ArrayOrConstant;
        } & {
            rtol: number;
        } & {
            atol: number;
        } & {
            equal_nan: boolean;
        }, atol: number | {
            a: ArrayOrConstant;
        } & {
            b: ArrayOrConstant;
        } & {
            rtol: number;
        } & {
            atol: number;
        } & {
            equal_nan: boolean;
        }, equal_nan: boolean | {
            a: ArrayOrConstant;
        } & {
            b: ArrayOrConstant;
        } & {
            rtol: number;
        } & {
            atol: number;
        } & {
            equal_nan: boolean;
        }]

      Returns NDArray

Constructors

arange

arange: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: number | {
            start: number;
        } & {
            stop: number;
        } & {
            step: number;
        } & {
            dtype: DType;
        }
      • Rest ...rest: [arg1: number | {
            start: number;
        } & {
            stop: number;
        } & {
            step: number;
        } & {
            dtype: DType;
        }, step: number | {
            start: number;
        } & {
            stop: number;
        } & {
            step: number;
        } & {
            dtype: DType;
        }, dtype: DType | {
            start: number;
        } & {
            stop: number;
        } & {
            step: number;
        } & {
            dtype: DType;
        }]

      Returns NDArray

asarray_chkfinite

asarray_chkfinite: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

ascontiguousarray

ascontiguousarray: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

asfortranarray

asfortranarray: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

asmatrix

asmatrix: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

bmat

bmat: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

diag

diag: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            v: ArrOrAny;
        } & {
            k: number;
        }
      • Rest ...rest: [k: number | {
            v: ArrOrAny;
        } & {
            k: number;
        }]

      Returns NDArray

diagflat

diagflat: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            v: ArrOrAny;
        } & {
            k: number;
        }
      • Rest ...rest: [k: number | {
            v: ArrOrAny;
        } & {
            k: number;
        }]

      Returns NDArray

empty

empty: Wrapper

empty_like

empty_like: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            dtype: DType;
        } & {
            shape: number[];
        }
      • Rest ...rest: [dtype: DType | {
            a: ArrOrAny;
        } & {
            dtype: DType;
        } & {
            shape: number[];
        }, shape: number[] | {
            a: ArrOrAny;
        } & {
            dtype: DType;
        } & {
            shape: number[];
        }]

      Returns NDArray

eye

eye: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: number | {
            N: number;
        } & {
            M: number;
        } & {
            k: number;
        } & {
            dtype: DType;
        }
      • Rest ...rest: [M: number | {
            N: number;
        } & {
            M: number;
        } & {
            k: number;
        } & {
            dtype: DType;
        }, k: number | {
            N: number;
        } & {
            M: number;
        } & {
            k: number;
        } & {
            dtype: DType;
        }, dtype: DType | {
            N: number;
        } & {
            M: number;
        } & {
            k: number;
        } & {
            dtype: DType;
        }]

      Returns NDArray

from_dlpack

from_dlpack: ((x) => NDArray)

Type declaration

frombuffer

frombuffer: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

fromfunction

fromfunction: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

fromiter

fromiter: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

full

full: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: number | number[] | {
            shape: number | number[];
        } & {
            fill_value: ArrOrAny;
        } & {
            dtype: DType;
        }
      • Rest ...rest: [fill_value: ArrOrAny | {
            shape: number | number[];
        } & {
            fill_value: ArrOrAny;
        } & {
            dtype: DType;
        }, dtype: DType | {
            shape: number | number[];
        } & {
            fill_value: ArrOrAny;
        } & {
            dtype: DType;
        }]

      Returns NDArray

full_like

full_like: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            fill_value: ArrOrAny;
        } & {
            dtype: DType;
        } & {
            shape: number[];
        }
      • Rest ...rest: [fill_value: ArrOrAny | {
            a: ArrOrAny;
        } & {
            fill_value: ArrOrAny;
        } & {
            dtype: DType;
        } & {
            shape: number[];
        }, dtype: DType | {
            a: ArrOrAny;
        } & {
            fill_value: ArrOrAny;
        } & {
            dtype: DType;
        } & {
            shape: number[];
        }, shape: number[] | {
            a: ArrOrAny;
        } & {
            fill_value: ArrOrAny;
        } & {
            dtype: DType;
        } & {
            shape: number[];
        }]

      Returns NDArray

geomspace

geomspace: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            start: ArrOrAny;
        } & {
            stop: ArrOrAny;
        } & {
            num: number;
        } & {
            endpoint: boolean;
        } & {
            dtype: DType;
        } & {
            axis: number;
        }
      • Rest ...rest: [stop: ArrOrAny | {
            start: ArrOrAny;
        } & {
            stop: ArrOrAny;
        } & {
            num: number;
        } & {
            endpoint: boolean;
        } & {
            dtype: DType;
        } & {
            axis: number;
        }, num: number | {
            start: ArrOrAny;
        } & {
            stop: ArrOrAny;
        } & {
            num: number;
        } & {
            endpoint: boolean;
        } & {
            dtype: DType;
        } & {
            axis: number;
        }, endpoint: boolean | {
            start: ArrOrAny;
        } & {
            stop: ArrOrAny;
        } & {
            num: number;
        } & {
            endpoint: boolean;
        } & {
            dtype: DType;
        } & {
            axis: number;
        }, dtype: DType | {
            start: ArrOrAny;
        } & {
            stop: ArrOrAny;
        } & {
            num: number;
        } & {
            endpoint: boolean;
        } & {
            dtype: DType;
        } & {
            axis: number;
        }, axis: number | {
            start: ArrOrAny;
        } & {
            stop: ArrOrAny;
        } & {
            num: number;
        } & {
            endpoint: boolean;
        } & {
            dtype: DType;
        } & {
            axis: number;
        }]

      Returns NDArray

identity

identity: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: number | {
            n: number;
        } & {
            dtype: DType;
        }
      • Rest ...rest: [dtype: DType | {
            n: number;
        } & {
            dtype: DType;
        }]

      Returns NDArray

linspace

linspace: ((a, ...rest) => any)

Type declaration

    • (a, ...rest): any

    • Parameters

      • a: ArrOrAny | {
            start: ArrOrAny;
        } & {
            stop: ArrOrAny;
        } & {
            num: number;
        } & {
            endpoint: boolean;
        } & {
            retstep: boolean;
        } & {
            dtype: DType;
        } & {
            axis: number;
        }
      • Rest ...rest: [stop: ArrOrAny | {
            start: ArrOrAny;
        } & {
            stop: ArrOrAny;
        } & {
            num: number;
        } & {
            endpoint: boolean;
        } & {
            retstep: boolean;
        } & {
            dtype: DType;
        } & {
            axis: number;
        }, num: number | {
            start: ArrOrAny;
        } & {
            stop: ArrOrAny;
        } & {
            num: number;
        } & {
            endpoint: boolean;
        } & {
            retstep: boolean;
        } & {
            dtype: DType;
        } & {
            axis: number;
        }, endpoint: boolean | {
            start: ArrOrAny;
        } & {
            stop: ArrOrAny;
        } & {
            num: number;
        } & {
            endpoint: boolean;
        } & {
            retstep: boolean;
        } & {
            dtype: DType;
        } & {
            axis: number;
        }]

      Returns any

logspace

logspace: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            start: ArrOrAny;
        } & {
            stop: ArrOrAny;
        } & {
            num: number;
        } & {
            endpoint: boolean;
        } & {
            base: number;
        } & {
            dtype: DType;
        } & {
            axis: number;
        }
      • Rest ...rest: [stop: ArrOrAny | {
            start: ArrOrAny;
        } & {
            stop: ArrOrAny;
        } & {
            num: number;
        } & {
            endpoint: boolean;
        } & {
            base: number;
        } & {
            dtype: DType;
        } & {
            axis: number;
        }, num: number | {
            start: ArrOrAny;
        } & {
            stop: ArrOrAny;
        } & {
            num: number;
        } & {
            endpoint: boolean;
        } & {
            base: number;
        } & {
            dtype: DType;
        } & {
            axis: number;
        }, endpoint: boolean | {
            start: ArrOrAny;
        } & {
            stop: ArrOrAny;
        } & {
            num: number;
        } & {
            endpoint: boolean;
        } & {
            base: number;
        } & {
            dtype: DType;
        } & {
            axis: number;
        }]

      Returns NDArray

mat

mat: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

meshgrid

meshgrid: ((a, ...rest) => NDArray[]) & ((...args) => NDArray[])

Type declaration

    • (a, ...rest): NDArray[]

    • Parameters

      • a: NDArray[] | {
            xi: NDArray[];
        } & {
            indexing: string;
        } & {
            sparse: boolean;
        } & {
            copy: boolean;
        }
      • Rest ...rest: [indexing: string | {
            xi: NDArray[];
        } & {
            indexing: string;
        } & {
            sparse: boolean;
        } & {
            copy: boolean;
        }, sparse: boolean | {
            xi: NDArray[];
        } & {
            indexing: string;
        } & {
            sparse: boolean;
        } & {
            copy: boolean;
        }, copy: boolean | {
            xi: NDArray[];
        } & {
            indexing: string;
        } & {
            sparse: boolean;
        } & {
            copy: boolean;
        }]

      Returns NDArray[]

Type declaration

mgrid

mgrid: ((a, ...rest) => any) & ((...args) => any)

Dense multi-dimensional grid from slice strings: np.mgrid('0:3', '0:2').

Type declaration

    • (a, ...rest): any

    • Parameters

      • a: any[] | {
            specs: any[];
        }
      • Rest ...rest: []

      Returns any

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

ogrid

ogrid: ((a, ...rest) => any) & ((...args) => any)

Open multi-dimensional grid from slice strings: np.ogrid('0:3', '0:2').

Type declaration

    • (a, ...rest): any

    • Parameters

      • a: any[] | {
            specs: any[];
        }
      • Rest ...rest: []

      Returns any

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

ones

ones: Wrapper

ones_like

ones_like: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            dtype: DType;
        } & {
            shape: number[];
        }
      • Rest ...rest: [dtype: DType | {
            a: ArrOrAny;
        } & {
            dtype: DType;
        } & {
            shape: number[];
        }, shape: number[] | {
            a: ArrOrAny;
        } & {
            dtype: DType;
        } & {
            shape: number[];
        }]

      Returns NDArray

rec

rec: {
    array: (() => never);
    format_parser: ((formats, names, titles?, aligned?, byteorder?) => FormatParser);
    fromarrays: (() => never);
    fromfile: (() => never);
    fromrecords: (() => never);
    fromstring: (() => never);
}

Record arrays are not supported (only the format parser is available).

Type declaration

  • array: (() => never)
      • (): never

      • Returns never

  • format_parser: ((formats, names, titles?, aligned?, byteorder?) => FormatParser)

    Parses the formats / names of a structured dtype (the dtype itself can not be used to create arrays)

      • (formats, names, titles?, aligned?, byteorder?): FormatParser

      • Parameters

        • formats: any
        • names: any
        • titles: any = null
        • aligned: boolean = false
        • byteorder: any = null

        Returns FormatParser

  • fromarrays: (() => never)
      • (): never

      • Returns never

  • fromfile: (() => never)
      • (): never

      • Returns never

  • fromrecords: (() => never)
      • (): never

      • Returns never

  • fromstring: (() => never)
      • (): never

      • Returns never

tri

tri: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: number | {
            N: number;
        } & {
            M: number;
        } & {
            k: number;
        } & {
            dtype: DType;
        }
      • Rest ...rest: [M: number | {
            N: number;
        } & {
            M: number;
        } & {
            k: number;
        } & {
            dtype: DType;
        }, k: number | {
            N: number;
        } & {
            M: number;
        } & {
            k: number;
        } & {
            dtype: DType;
        }, dtype: DType | {
            N: number;
        } & {
            M: number;
        } & {
            k: number;
        } & {
            dtype: DType;
        }]

      Returns NDArray

tril

tril: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            m: ArrOrAny;
        } & {
            k: number;
        }
      • Rest ...rest: [k: number | {
            m: ArrOrAny;
        } & {
            k: number;
        }]

      Returns NDArray

triu

triu: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            m: ArrOrAny;
        } & {
            k: number;
        }
      • Rest ...rest: [k: number | {
            m: ArrOrAny;
        } & {
            k: number;
        }]

      Returns NDArray

vander

vander: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            x: ArrOrAny;
        } & {
            N: number;
        } & {
            increasing: boolean;
        }
      • Rest ...rest: [N: number | {
            x: ArrOrAny;
        } & {
            N: number;
        } & {
            increasing: boolean;
        }, increasing: boolean | {
            x: ArrOrAny;
        } & {
            N: number;
        } & {
            increasing: boolean;
        }]

      Returns NDArray

zeros

zeros: Wrapper

zeros_like

zeros_like: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            dtype: DType;
        } & {
            shape: number[];
        }
      • Rest ...rest: [dtype: DType | {
            a: ArrOrAny;
        } & {
            dtype: DType;
        } & {
            shape: number[];
        }, shape: number[] | {
            a: ArrOrAny;
        } & {
            dtype: DType;
        } & {
            shape: number[];
        }]

      Returns NDArray

Cumulative

cumprod

cumprod: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }
      • Rest ...rest: [axis: number | {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }, dtype: DType | {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }, out: ArrOrAny | {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }]

      Returns NDArray

cumsum

cumsum: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }
      • Rest ...rest: [axis: number | {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }, dtype: DType | {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }, out: ArrOrAny | {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }]

      Returns NDArray

cumulative_prod

cumulative_prod: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            x: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        } & {
            include_initial: boolean;
        }
      • Rest ...rest: [axis: number | {
            x: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        } & {
            include_initial: boolean;
        }, dtype: DType | {
            x: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        } & {
            include_initial: boolean;
        }, out: ArrOrAny | {
            x: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        } & {
            include_initial: boolean;
        }, include_initial: boolean | {
            x: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        } & {
            include_initial: boolean;
        }]

      Returns NDArray

cumulative_sum

cumulative_sum: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            x: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        } & {
            include_initial: boolean;
        }
      • Rest ...rest: [axis: number | {
            x: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        } & {
            include_initial: boolean;
        }, dtype: DType | {
            x: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        } & {
            include_initial: boolean;
        }, out: ArrOrAny | {
            x: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        } & {
            include_initial: boolean;
        }, include_initial: boolean | {
            x: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        } & {
            include_initial: boolean;
        }]

      Returns NDArray

nancumprod

nancumprod: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }
      • Rest ...rest: [axis: number | {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }, dtype: DType | {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }, out: ArrOrAny | {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }]

      Returns NDArray

nancumsum

nancumsum: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }
      • Rest ...rest: [axis: number | {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }, dtype: DType | {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }, out: ArrOrAny | {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }]

      Returns NDArray

Differences

diff

diff: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            n: number;
        } & {
            axis: number;
        } & {
            prepend: ArrOrAny;
        } & {
            append: ArrOrAny;
        }
      • Rest ...rest: [n: number | {
            a: ArrOrAny;
        } & {
            n: number;
        } & {
            axis: number;
        } & {
            prepend: ArrOrAny;
        } & {
            append: ArrOrAny;
        }, axis: number | {
            a: ArrOrAny;
        } & {
            n: number;
        } & {
            axis: number;
        } & {
            prepend: ArrOrAny;
        } & {
            append: ArrOrAny;
        }, prepend: ArrOrAny | {
            a: ArrOrAny;
        } & {
            n: number;
        } & {
            axis: number;
        } & {
            prepend: ArrOrAny;
        } & {
            append: ArrOrAny;
        }, append: ArrOrAny | {
            a: ArrOrAny;
        } & {
            n: number;
        } & {
            axis: number;
        } & {
            prepend: ArrOrAny;
        } & {
            append: ArrOrAny;
        }]

      Returns NDArray

ediff1d

ediff1d: ((a, ...rest) => NDArray)

Type declaration

gradient

gradient: ((a, ...rest) => NDArray | NDArray[]) & ((...args) => NDArray | NDArray[])

Type declaration

    • (a, ...rest): NDArray | NDArray[]

    • Parameters

      • a: ArrOrAny | {
            f: ArrOrAny;
        } & {
            varargs: any[];
        } & {
            axis: AxisArg;
        } & {
            edge_order: number;
        }
      • Rest ...rest: [varargs: any[] | {
            f: ArrOrAny;
        } & {
            varargs: any[];
        } & {
            axis: AxisArg;
        } & {
            edge_order: number;
        }, axis: AxisArg | {
            f: ArrOrAny;
        } & {
            varargs: any[];
        } & {
            axis: AxisArg;
        } & {
            edge_order: number;
        }, edge_order: number | {
            f: ArrOrAny;
        } & {
            varargs: any[];
        } & {
            axis: AxisArg;
        } & {
            edge_order: number;
        }]

      Returns NDArray | NDArray[]

Type declaration

Elementwise operators

abs

abs: Wrapper

acos

acos: Wrapper

acosh

acosh: Wrapper

angle

angle: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            z: ArrOrAny;
        } & {
            deg: boolean;
        }
      • Rest ...rest: [deg: boolean | {
            z: ArrOrAny;
        } & {
            deg: boolean;
        }]

      Returns NDArray

around

around: Wrapper

asin

asin: Wrapper

asinh

asinh: Wrapper

atan

atan: Wrapper

atanh

atanh: Wrapper

bitwise_not

bitwise_not: Wrapper

cbrt

cbrt: Wrapper

ceil

ceil: Wrapper

clip

clip: Wrapper

conj

conj: Wrapper

conjugate

conjugate: Wrapper

cos

cos: Wrapper

cosh

cosh: Wrapper

deg2rad

deg2rad: Wrapper

degrees

degrees: Wrapper

exp

exp: Wrapper

exp2

exp2: Wrapper

expm1

expm1: Wrapper

fix

fix: Wrapper

floor

floor: Wrapper

frexp

frexp: ((a, ...rest) => NDArray[])

Type declaration

i0

i0: Wrapper

imag

imag: Wrapper

invert

invert: Wrapper

iscomplex

iscomplex: Wrapper

isfinite

isfinite: Wrapper

isinf

isinf: Wrapper

isnan

isnan: Wrapper

isneginf

isneginf: Wrapper

isposinf

isposinf: Wrapper

isreal

isreal: Wrapper

log

log: Wrapper

log10

log10: Wrapper

log1p

log1p: Wrapper

log2

log2: Wrapper

logical_not

logical_not: Wrapper

modf

modf: ((a, ...rest) => NDArray[])

Type declaration

nan_to_num

nan_to_num: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            nan: number;
        } & {
            posinf: number;
        } & {
            neginf: number;
        } & {
            out: DType | NDArray;
        }
      • Rest ...rest: [nan: number | {
            a: ArrOrAny;
        } & {
            nan: number;
        } & {
            posinf: number;
        } & {
            neginf: number;
        } & {
            out: DType | NDArray;
        }, posinf: number | {
            a: ArrOrAny;
        } & {
            nan: number;
        } & {
            posinf: number;
        } & {
            neginf: number;
        } & {
            out: DType | NDArray;
        }, neginf: number | {
            a: ArrOrAny;
        } & {
            nan: number;
        } & {
            posinf: number;
        } & {
            neginf: number;
        } & {
            out: DType | NDArray;
        }, out: DType | NDArray | {
            a: ArrOrAny;
        } & {
            nan: number;
        } & {
            posinf: number;
        } & {
            neginf: number;
        } & {
            out: DType | NDArray;
        }]

      Returns NDArray

negative

negative: Wrapper

positive

positive: Wrapper

rad2deg

rad2deg: Wrapper

radians

radians: Wrapper

real

real: Wrapper

real_if_close

real_if_close: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            tol: number;
        }
      • Rest ...rest: [tol: number | {
            a: ArrOrAny;
        } & {
            tol: number;
        }]

      Returns NDArray

reciprocal

reciprocal: Wrapper

rint

rint: Wrapper

round

round: Wrapper

sign

sign: Wrapper

signbit

signbit: Wrapper

sin

sin: Wrapper

sinc

sinc: Wrapper

sinh

sinh: Wrapper

spacing

spacing: Wrapper

sqrt

sqrt: Wrapper

square

square: Wrapper

tan

tan: Wrapper

tanh

tanh: Wrapper

trunc

trunc: Wrapper

valueOf

valueOf: Wrapper

Error handling

exceptions

exceptions: {
    AxisError: typeof AxisError;
    ComplexWarning: typeof __class;
    DTypePromotionError: typeof __class;
    ModuleDeprecationWarning: typeof __class;
    RankWarning: typeof __class;
    TooHardError: typeof __class;
    VisibleDeprecationWarning: typeof __class;
}

Type declaration

geterr

geterr: (() => {
    divide: ErrMode;
    invalid: ErrMode;
    over: ErrMode;
    under: ErrMode;
})

Type declaration

geterrcall

geterrcall: (() => any)

Type declaration

    • (): any

    • Returns any

seterr

seterr: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

seterrcall

seterrcall: ((func) => any)

Type declaration

    • (func): any

    • Parameters

      • func: any

      Returns any

errstate

  • errstate(options?, fn?): any

  • Parameters

    • Optional options: any
    • Optional fn: (() => any)
        • (): any

        • Returns any

    Returns any

FFT

fft

fft: {
    fft: ((a, ...rest) => NDArray);
    fft2: ((a, ...rest) => NDArray);
    fftfreq: ((a, ...rest) => NDArray);
    fftn: ((a, ...rest) => NDArray);
    fftshift: ((a, ...rest) => NDArray);
    hfft: ((a, ...rest) => NDArray);
    ifft: ((a, ...rest) => NDArray);
    ifft2: ((a, ...rest) => NDArray);
    ifftn: ((a, ...rest) => NDArray);
    ifftshift: ((a, ...rest) => NDArray);
    ihfft: ((a, ...rest) => NDArray);
    irfft: ((a, ...rest) => NDArray);
    irfft2: ((a, ...rest) => NDArray);
    irfftn: ((a, ...rest) => NDArray);
    rfft: ((a, ...rest) => NDArray);
    rfft2: ((a, ...rest) => NDArray);
    rfftfreq: ((a, ...rest) => NDArray);
    rfftn: ((a, ...rest) => NDArray);
}

Discrete Fourier transforms (numpy.fft)

Type declaration

  • fft: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }
        • Rest ...rest: [n: number | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }, axis: number | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }, norm: Norm | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }]

        Returns NDArray

  • fft2: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }
        • Rest ...rest: [s: number[] | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }, axes: number[] | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }, norm: Norm | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }]

        Returns NDArray

  • fftfreq: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: number | {
              n: number;
          } & {
              d: number;
          }
        • Rest ...rest: [d: number | {
              n: number;
          } & {
              d: number;
          }]

        Returns NDArray

  • fftn: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }
        • Rest ...rest: [s: number[] | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }, axes: number[] | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }, norm: Norm | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }]

        Returns NDArray

  • fftshift: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              x: ArrOrAny;
          } & {
              axes: number | number[];
          }
        • Rest ...rest: [axes: number | number[] | {
              x: ArrOrAny;
          } & {
              axes: number | number[];
          }]

        Returns NDArray

  • hfft: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }
        • Rest ...rest: [n: number | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }, axis: number | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }, norm: Norm | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }]

        Returns NDArray

  • ifft: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }
        • Rest ...rest: [n: number | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }, axis: number | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }, norm: Norm | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }]

        Returns NDArray

  • ifft2: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }
        • Rest ...rest: [s: number[] | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }, axes: number[] | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }, norm: Norm | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }]

        Returns NDArray

  • ifftn: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }
        • Rest ...rest: [s: number[] | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }, axes: number[] | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }, norm: Norm | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }]

        Returns NDArray

  • ifftshift: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              x: ArrOrAny;
          } & {
              axes: number | number[];
          }
        • Rest ...rest: [axes: number | number[] | {
              x: ArrOrAny;
          } & {
              axes: number | number[];
          }]

        Returns NDArray

  • ihfft: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }
        • Rest ...rest: [n: number | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }, axis: number | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }, norm: Norm | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }]

        Returns NDArray

  • irfft: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }
        • Rest ...rest: [n: number | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }, axis: number | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }, norm: Norm | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }]

        Returns NDArray

  • irfft2: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }
        • Rest ...rest: [s: number[] | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }, axes: number[] | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }, norm: Norm | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }]

        Returns NDArray

  • irfftn: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }
        • Rest ...rest: [s: number[] | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }, axes: number[] | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }, norm: Norm | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }]

        Returns NDArray

  • rfft: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }
        • Rest ...rest: [n: number | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }, axis: number | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }, norm: Norm | {
              a: ArrOrAny;
          } & {
              n: number;
          } & {
              axis: number;
          } & {
              norm: Norm;
          }]

        Returns NDArray

  • rfft2: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }
        • Rest ...rest: [s: number[] | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }, axes: number[] | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }, norm: Norm | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }]

        Returns NDArray

  • rfftfreq: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: number | {
              n: number;
          } & {
              d: number;
          }
        • Rest ...rest: [d: number | {
              n: number;
          } & {
              d: number;
          }]

        Returns NDArray

  • rfftn: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }
        • Rest ...rest: [s: number[] | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }, axes: number[] | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }, norm: Norm | {
              a: ArrOrAny;
          } & {
              s: number[];
          } & {
              axes: number[];
          } & {
              norm: Norm;
          }]

        Returns NDArray

Formatting

array2string

array2string: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

array_repr

array_repr: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

array_str

array_str: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

base_repr

base_repr: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

binary_repr

binary_repr: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

format_float_positional

format_float_positional: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

format_float_scientific

format_float_scientific: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

get_printoptions

get_printoptions: (() => PrintOptions)

Type declaration

packbits

packbits: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

set_printoptions

set_printoptions: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

unpackbits

unpackbits: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

printoptions

  • printoptions(opts, fn?): any

  • Parameters

    • opts: any
    • Optional fn: (() => any)
        • (): any

        • Returns any

    Returns any

Functional

apply_over_axes

apply_over_axes: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ((a, axis) => NDArray) | {
            func: ((a, axis) => NDArray);
        } & {
            a: ArrOrAny;
        } & {
            axes: number | number[];
        }
      • Rest ...rest: [a: ArrOrAny | {
            func: ((a, axis) => NDArray);
        } & {
            a: ArrOrAny;
        } & {
            axes: number | number[];
        }, axes: number | number[] | {
            func: ((a, axis) => NDArray);
        } & {
            a: ArrOrAny;
        } & {
            axes: number | number[];
        }]

      Returns NDArray

frompyfunc

frompyfunc: ((func, nin, nout, identity?) => ((...args) => NDArray | NDArray[]) & {
    identity: any;
    nin: number;
    nout: number;
})

Type declaration

    • (func, nin, nout, identity?): ((...args) => NDArray | NDArray[]) & {
          identity: any;
          nin: number;
          nout: number;
      }

    • Parameters

      • func: ((...args) => any)
          • (...args): any

          • Parameters

            • Rest ...args: any[]

            Returns any

      • nin: number
      • nout: number
      • identity: any = null

      Returns ((...args) => NDArray | NDArray[]) & {
          identity: any;
          nin: number;
          nout: number;
      }

piecewise

  • piecewise(x, condlist, funclist, ...args): NDArray

  • Parameters

    • x: any
    • condlist: any
    • funclist: any
    • Rest ...args: any[]

    Returns NDArray

vectorize

  • vectorize(pyfunc, options?): ((...args) => any)

  • Parameters

    • pyfunc: ((...args) => any)
        • (...args): any

        • Parameters

          • Rest ...args: any[]

          Returns any

    • options: VectorizeOptions = {}

    Returns ((...args) => any)

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

Histograms

bincount

bincount: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            x: ArrOrAny;
        } & {
            weights: ArrOrAny;
        } & {
            minlength: number;
        }
      • Rest ...rest: [weights: ArrOrAny | {
            x: ArrOrAny;
        } & {
            weights: ArrOrAny;
        } & {
            minlength: number;
        }, minlength: number | {
            x: ArrOrAny;
        } & {
            weights: ArrOrAny;
        } & {
            minlength: number;
        }]

      Returns NDArray

digitize

digitize: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            x: ArrOrAny;
        } & {
            bins: ArrOrAny;
        } & {
            right: boolean;
        }
      • Rest ...rest: [bins: ArrOrAny | {
            x: ArrOrAny;
        } & {
            bins: ArrOrAny;
        } & {
            right: boolean;
        }, right: boolean | {
            x: ArrOrAny;
        } & {
            bins: ArrOrAny;
        } & {
            right: boolean;
        }]

      Returns NDArray

histogram

histogram: ((a, ...rest) => NDArray[])

Type declaration

    • (a, ...rest): NDArray[]

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            bins: string | number | number[] | NDArray;
        } & {
            range: [number, number];
        } & {
            density: boolean;
        } & {
            weights: ArrOrAny;
        }
      • Rest ...rest: [bins: string | number | number[] | NDArray | {
            a: ArrOrAny;
        } & {
            bins: string | number | number[] | NDArray;
        } & {
            range: [number, number];
        } & {
            density: boolean;
        } & {
            weights: ArrOrAny;
        }, range: [number, number] | {
            a: ArrOrAny;
        } & {
            bins: string | number | number[] | NDArray;
        } & {
            range: [number, number];
        } & {
            density: boolean;
        } & {
            weights: ArrOrAny;
        }, density: boolean | {
            a: ArrOrAny;
        } & {
            bins: string | number | number[] | NDArray;
        } & {
            range: [number, number];
        } & {
            density: boolean;
        } & {
            weights: ArrOrAny;
        }, weights: ArrOrAny | {
            a: ArrOrAny;
        } & {
            bins: string | number | number[] | NDArray;
        } & {
            range: [number, number];
        } & {
            density: boolean;
        } & {
            weights: ArrOrAny;
        }]

      Returns NDArray[]

histogram2d

histogram2d: ((a, ...rest) => NDArray[])

Type declaration

    • (a, ...rest): NDArray[]

    • Parameters

      • a: ArrOrAny | {
            x: ArrOrAny;
        } & {
            y: ArrOrAny;
        } & {
            bins: ArrOrAny;
        } & {
            range: any[];
        } & {
            density: boolean;
        } & {
            weights: ArrOrAny;
        }
      • Rest ...rest: [y: ArrOrAny | {
            x: ArrOrAny;
        } & {
            y: ArrOrAny;
        } & {
            bins: ArrOrAny;
        } & {
            range: any[];
        } & {
            density: boolean;
        } & {
            weights: ArrOrAny;
        }, bins: ArrOrAny | {
            x: ArrOrAny;
        } & {
            y: ArrOrAny;
        } & {
            bins: ArrOrAny;
        } & {
            range: any[];
        } & {
            density: boolean;
        } & {
            weights: ArrOrAny;
        }, range: any[] | {
            x: ArrOrAny;
        } & {
            y: ArrOrAny;
        } & {
            bins: ArrOrAny;
        } & {
            range: any[];
        } & {
            density: boolean;
        } & {
            weights: ArrOrAny;
        }, density: boolean | {
            x: ArrOrAny;
        } & {
            y: ArrOrAny;
        } & {
            bins: ArrOrAny;
        } & {
            range: any[];
        } & {
            density: boolean;
        } & {
            weights: ArrOrAny;
        }, weights: ArrOrAny | {
            x: ArrOrAny;
        } & {
            y: ArrOrAny;
        } & {
            bins: ArrOrAny;
        } & {
            range: any[];
        } & {
            density: boolean;
        } & {
            weights: ArrOrAny;
        }]

      Returns NDArray[]

histogram_bin_edges

histogram_bin_edges: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            bins: string | number | number[] | NDArray;
        } & {
            range: [number, number];
        } & {
            weights: ArrOrAny;
        }
      • Rest ...rest: [bins: string | number | number[] | NDArray | {
            a: ArrOrAny;
        } & {
            bins: string | number | number[] | NDArray;
        } & {
            range: [number, number];
        } & {
            weights: ArrOrAny;
        }, range: [number, number] | {
            a: ArrOrAny;
        } & {
            bins: string | number | number[] | NDArray;
        } & {
            range: [number, number];
        } & {
            weights: ArrOrAny;
        }, weights: ArrOrAny | {
            a: ArrOrAny;
        } & {
            bins: string | number | number[] | NDArray;
        } & {
            range: [number, number];
        } & {
            weights: ArrOrAny;
        }]

      Returns NDArray

histogramdd

histogramdd: ((a, ...rest) => [NDArray, NDArray[]])

Type declaration

    • (a, ...rest): [NDArray, NDArray[]]

    • Parameters

      • a: ArrOrAny | {
            sample: ArrOrAny;
        } & {
            bins: ArrOrAny;
        } & {
            range: any[];
        } & {
            density: boolean;
        } & {
            weights: ArrOrAny;
        }
      • Rest ...rest: [bins: ArrOrAny | {
            sample: ArrOrAny;
        } & {
            bins: ArrOrAny;
        } & {
            range: any[];
        } & {
            density: boolean;
        } & {
            weights: ArrOrAny;
        }, range: any[] | {
            sample: ArrOrAny;
        } & {
            bins: ArrOrAny;
        } & {
            range: any[];
        } & {
            density: boolean;
        } & {
            weights: ArrOrAny;
        }, density: boolean | {
            sample: ArrOrAny;
        } & {
            bins: ArrOrAny;
        } & {
            range: any[];
        } & {
            density: boolean;
        } & {
            weights: ArrOrAny;
        }, weights: ArrOrAny | {
            sample: ArrOrAny;
        } & {
            bins: ArrOrAny;
        } & {
            range: any[];
        } & {
            density: boolean;
        } & {
            weights: ArrOrAny;
        }]

      Returns [NDArray, NDArray[]]

Index generators

diag_indices

diag_indices: ((a, ...rest) => NDArray[])

Type declaration

    • (a, ...rest): NDArray[]

    • Parameters

      • a: number | {
            n: number;
        } & {
            ndim: number;
        }
      • Rest ...rest: [ndim: number | {
            n: number;
        } & {
            ndim: number;
        }]

      Returns NDArray[]

diag_indices_from

diag_indices_from: ((a, ...rest) => NDArray[])

Type declaration

indices

indices: ((a, ...rest) => NDArray | NDArray[])

Type declaration

    • (a, ...rest): NDArray | NDArray[]

    • Parameters

      • a: number[] | {
            dimensions: number[];
        } & {
            dtype: DType;
        } & {
            sparse: boolean;
        }
      • Rest ...rest: [dtype: DType | {
            dimensions: number[];
        } & {
            dtype: DType;
        } & {
            sparse: boolean;
        }, sparse: boolean | {
            dimensions: number[];
        } & {
            dtype: DType;
        } & {
            sparse: boolean;
        }]

      Returns NDArray | NDArray[]

ix_

ix_: ((a, ...rest) => NDArray[]) & ((...args) => NDArray[])

Type declaration

Type declaration

mask_indices

mask_indices: ((a, ...rest) => NDArray[])

Type declaration

    • (a, ...rest): NDArray[]

    • Parameters

      • a: number | {
            n: number;
        } & {
            mask_func: ((m, k) => NDArray);
        } & {
            k: number;
        }
      • Rest ...rest: [mask_func: ((m, k) => NDArray) | {
            n: number;
        } & {
            mask_func: ((m, k) => NDArray);
        } & {
            k: number;
        }, k: number | {
            n: number;
        } & {
            mask_func: ((m, k) => NDArray);
        } & {
            k: number;
        }]

      Returns NDArray[]

ravel_multi_index

ravel_multi_index: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: NDArray[] | {
            multi_index: NDArray[];
        } & {
            dims: number | number[];
        } & {
            mode: IndexMode | IndexMode[];
        } & {
            order: "F" | "C";
        }
      • Rest ...rest: [dims: number | number[] | {
            multi_index: NDArray[];
        } & {
            dims: number | number[];
        } & {
            mode: IndexMode | IndexMode[];
        } & {
            order: "F" | "C";
        }, mode: IndexMode | IndexMode[] | {
            multi_index: NDArray[];
        } & {
            dims: number | number[];
        } & {
            mode: IndexMode | IndexMode[];
        } & {
            order: "F" | "C";
        }, order: "F" | "C" | {
            multi_index: NDArray[];
        } & {
            dims: number | number[];
        } & {
            mode: IndexMode | IndexMode[];
        } & {
            order: "F" | "C";
        }]

      Returns NDArray

tril_indices

tril_indices: ((a, ...rest) => NDArray[])

Type declaration

    • (a, ...rest): NDArray[]

    • Parameters

      • a: number | {
            n: number;
        } & {
            k: number;
        } & {
            m: number;
        }
      • Rest ...rest: [k: number | {
            n: number;
        } & {
            k: number;
        } & {
            m: number;
        }, m: number | {
            n: number;
        } & {
            k: number;
        } & {
            m: number;
        }]

      Returns NDArray[]

tril_indices_from

tril_indices_from: ((a, ...rest) => NDArray[])

Type declaration

    • (a, ...rest): NDArray[]

    • Parameters

      • a: ArrOrAny | {
            arr: ArrOrAny;
        } & {
            k: number;
        }
      • Rest ...rest: [k: number | {
            arr: ArrOrAny;
        } & {
            k: number;
        }]

      Returns NDArray[]

triu_indices

triu_indices: ((a, ...rest) => NDArray[])

Type declaration

    • (a, ...rest): NDArray[]

    • Parameters

      • a: number | {
            n: number;
        } & {
            k: number;
        } & {
            m: number;
        }
      • Rest ...rest: [k: number | {
            n: number;
        } & {
            k: number;
        } & {
            m: number;
        }, m: number | {
            n: number;
        } & {
            k: number;
        } & {
            m: number;
        }]

      Returns NDArray[]

triu_indices_from

triu_indices_from: ((a, ...rest) => NDArray[])

Type declaration

    • (a, ...rest): NDArray[]

    • Parameters

      • a: ArrOrAny | {
            arr: ArrOrAny;
        } & {
            k: number;
        }
      • Rest ...rest: [k: number | {
            arr: ArrOrAny;
        } & {
            k: number;
        }]

      Returns NDArray[]

unravel_index

unravel_index: ((a, ...rest) => NDArray[])

Type declaration

    • (a, ...rest): NDArray[]

    • Parameters

      • a: ArrOrAny | {
            indices: ArrOrAny;
        } & {
            shape: number | number[];
        } & {
            order: "F" | "C";
        }
      • Rest ...rest: [shape: number | number[] | {
            indices: ArrOrAny;
        } & {
            shape: number | number[];
        } & {
            order: "F" | "C";
        }, order: "F" | "C" | {
            indices: ArrOrAny;
        } & {
            shape: number | number[];
        } & {
            order: "F" | "C";
        }]

      Returns NDArray[]

Index tricks

c_

c_: ((...items) => NDArray) & {
    index: ((...items) => NDArray);
}

Type declaration

Type declaration

index_exp

index_exp: ((...args) => any[]) & {
    index: ((...args) => any[]);
}

Type declaration

    • (...args): any[]

    • Parameters

      • Rest ...args: any[]

      Returns any[]

Type declaration

  • index: ((...args) => any[])
      • (...args): any[]

      • Parameters

        • Rest ...args: any[]

        Returns any[]

r_

r_: ((...items) => NDArray) & {
    index: ((...items) => NDArray);
}

Type declaration

Type declaration

s_

s_: ((...args) => any) & {
    index: ((...args) => any);
}

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

Type declaration

  • index: ((...args) => any)
      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

Indexing

choose

choose: ((a, ...rest) => NDArray)

Type declaration

compress

compress: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            condition: ArrOrAny;
        } & {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            out: ArrOrAny;
        }
      • Rest ...rest: [a: ArrOrAny | {
            condition: ArrOrAny;
        } & {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            out: ArrOrAny;
        }, axis: number | {
            condition: ArrOrAny;
        } & {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            out: ArrOrAny;
        }, out: ArrOrAny | {
            condition: ArrOrAny;
        } & {
            a: ArrOrAny;
        } & {
            axis: number;
        } & {
            out: ArrOrAny;
        }]

      Returns NDArray

diagonal

diagonal: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            offset: number;
        } & {
            axis1: number;
        } & {
            axis2: number;
        }
      • Rest ...rest: [offset: number | {
            a: ArrOrAny;
        } & {
            offset: number;
        } & {
            axis1: number;
        } & {
            axis2: number;
        }, axis1: number | {
            a: ArrOrAny;
        } & {
            offset: number;
        } & {
            axis1: number;
        } & {
            axis2: number;
        }, axis2: number | {
            a: ArrOrAny;
        } & {
            offset: number;
        } & {
            axis1: number;
        } & {
            axis2: number;
        }]

      Returns NDArray

fill_diagonal

fill_diagonal: ((a, ...rest) => void)

Type declaration

    • (a, ...rest): void

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            val: ArrOrAny;
        } & {
            wrap: boolean;
        }
      • Rest ...rest: [val: ArrOrAny | {
            a: ArrOrAny;
        } & {
            val: ArrOrAny;
        } & {
            wrap: boolean;
        }, wrap: boolean | {
            a: ArrOrAny;
        } & {
            val: ArrOrAny;
        } & {
            wrap: boolean;
        }]

      Returns void

place

place: ((a, ...rest) => void)

Type declaration

put

put: ((a, ...rest) => void)

Type declaration

put_along_axis

put_along_axis: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            arr: ArrOrAny;
        } & {
            indices: ArrOrAny;
        } & {
            values: ArrOrAny;
        } & {
            axis: number;
        }
      • Rest ...rest: [indices: ArrOrAny | {
            arr: ArrOrAny;
        } & {
            indices: ArrOrAny;
        } & {
            values: ArrOrAny;
        } & {
            axis: number;
        }, values: ArrOrAny | {
            arr: ArrOrAny;
        } & {
            indices: ArrOrAny;
        } & {
            values: ArrOrAny;
        } & {
            axis: number;
        }, axis: number | {
            arr: ArrOrAny;
        } & {
            indices: ArrOrAny;
        } & {
            values: ArrOrAny;
        } & {
            axis: number;
        }]

      Returns NDArray

putmask

putmask: ((a, ...rest) => void)

Type declaration

select

select: ((a, ...rest) => NDArray)

Type declaration

take

take: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            indices: ArrOrAny;
        } & {
            axis: number;
        } & {
            out: ArrOrAny;
        } & {
            mode: IndexMode;
        }
      • Rest ...rest: [indices: ArrOrAny | {
            a: ArrOrAny;
        } & {
            indices: ArrOrAny;
        } & {
            axis: number;
        } & {
            out: ArrOrAny;
        } & {
            mode: IndexMode;
        }, axis: number | {
            a: ArrOrAny;
        } & {
            indices: ArrOrAny;
        } & {
            axis: number;
        } & {
            out: ArrOrAny;
        } & {
            mode: IndexMode;
        }, out: ArrOrAny | {
            a: ArrOrAny;
        } & {
            indices: ArrOrAny;
        } & {
            axis: number;
        } & {
            out: ArrOrAny;
        } & {
            mode: IndexMode;
        }, mode: IndexMode | {
            a: ArrOrAny;
        } & {
            indices: ArrOrAny;
        } & {
            axis: number;
        } & {
            out: ArrOrAny;
        } & {
            mode: IndexMode;
        }]

      Returns NDArray

take_along_axis

take_along_axis: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            arr: ArrOrAny;
        } & {
            indices: ArrOrAny;
        } & {
            axis: number;
        }
      • Rest ...rest: [indices: ArrOrAny | {
            arr: ArrOrAny;
        } & {
            indices: ArrOrAny;
        } & {
            axis: number;
        }, axis: number | {
            arr: ArrOrAny;
        } & {
            indices: ArrOrAny;
        } & {
            axis: number;
        }]

      Returns NDArray

Input and output

fromfile

fromfile: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

fromregex

fromregex: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

fromstring

fromstring: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

genfromtxt

genfromtxt: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

lib

lib: {
    format: {
        descr_to_dtype: ((descr) => DType);
        dtype_to_descr: ((dtype) => string);
        header_data_from_array_1_0: ((arr) => {
            descr: string;
            fortran_order: boolean;
            shape: number[];
        });
        magic: ((major?, minor?) => Uint8Array);
        open_memmap: ((filename, mode?, dtype?, shape?, fortran_order?) => NDArray & {
            flush: (() => void);
        });
        read_array: ((bytes) => NDArray);
        read_array_header_1_0: ((bytes) => (boolean | number[] | DType)[]);
        read_magic: ((bytes) => number[]);
        write_array: ((arr) => Uint8Array);
    };
    npyio: {
        DataSource: typeof DataSource;
        NpzFile: typeof NpzFile;
    };
}

Type declaration

  • format: {
        descr_to_dtype: ((descr) => DType);
        dtype_to_descr: ((dtype) => string);
        header_data_from_array_1_0: ((arr) => {
            descr: string;
            fortran_order: boolean;
            shape: number[];
        });
        magic: ((major?, minor?) => Uint8Array);
        open_memmap: ((filename, mode?, dtype?, shape?, fortran_order?) => NDArray & {
            flush: (() => void);
        });
        read_array: ((bytes) => NDArray);
        read_array_header_1_0: ((bytes) => (boolean | number[] | DType)[]);
        read_magic: ((bytes) => number[]);
        write_array: ((arr) => Uint8Array);
    }
    • descr_to_dtype: ((descr) => DType)
        • (descr): DType

        • Parameters

          • descr: string

          Returns DType

    • dtype_to_descr: ((dtype) => string)
        • (dtype): string

        • Parameters

          • dtype: any

          Returns string

    • header_data_from_array_1_0: ((arr) => {
          descr: string;
          fortran_order: boolean;
          shape: number[];
      })
        • (arr): {
              descr: string;
              fortran_order: boolean;
              shape: number[];
          }

        • Parameters

          • arr: any

          Returns {
              descr: string;
              fortran_order: boolean;
              shape: number[];
          }

          • descr: string
          • fortran_order: boolean
          • shape: number[]
    • magic: ((major?, minor?) => Uint8Array)
        • (major?, minor?): Uint8Array

        • Parameters

          • major: number = 1
          • minor: number = 0

          Returns Uint8Array

    • open_memmap: ((filename, mode?, dtype?, shape?, fortran_order?) => NDArray & {
          flush: (() => void);
      })
        • (filename, mode?, dtype?, shape?, fortran_order?): NDArray & {
              flush: (() => void);
          }

        • Parameters

          • filename: string
          • mode: "r" | "c" | "r+" | "w+" = 'r+'
          • dtype: string = null
          • shape: number[] = null
          • fortran_order: boolean = false

          Returns NDArray & {
              flush: (() => void);
          }

    • read_array: ((bytes) => NDArray)
    • read_array_header_1_0: ((bytes) => (boolean | number[] | DType)[])
        • (bytes): (boolean | number[] | DType)[]

        • Parameters

          • bytes: any

          Returns (boolean | number[] | DType)[]

    • read_magic: ((bytes) => number[])
        • (bytes): number[]

        • Parameters

          • bytes: any

          Returns number[]

    • write_array: ((arr) => Uint8Array)
        • (arr): Uint8Array

        • Parameters

          • arr: any

          Returns Uint8Array

  • npyio: {
        DataSource: typeof DataSource;
        NpzFile: typeof NpzFile;
    }

load

load: ((...args) => any)

Loads .npy / .npz files (path or bytes).

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

loadtxt

loadtxt: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

memmap

memmap: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

save

save: ((...args) => any)

Saves an array in .npy format (path, or null to get the bytes).

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

savetxt

savetxt: ((...args) => any)

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

savez

  • savez(file, ...args): Uint8Array

  • Parameters

    • file: any
    • Rest ...args: any[]

    Returns Uint8Array

savez_compressed

  • savez_compressed(file, ...args): Uint8Array

  • Parameters

    • file: any
    • Rest ...args: any[]

    Returns Uint8Array

Inserting and deleting

append

append: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            arr: ArrOrAny;
        } & {
            values: ArrOrAny;
        } & {
            axis: number;
        }
      • Rest ...rest: [values: ArrOrAny | {
            arr: ArrOrAny;
        } & {
            values: ArrOrAny;
        } & {
            axis: number;
        }, axis: number | {
            arr: ArrOrAny;
        } & {
            values: ArrOrAny;
        } & {
            axis: number;
        }]

      Returns NDArray

delete

delete: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            arr: ArrOrAny;
        } & {
            obj: ArrOrAny;
        } & {
            axis: number;
        }
      • Rest ...rest: [obj: ArrOrAny | {
            arr: ArrOrAny;
        } & {
            obj: ArrOrAny;
        } & {
            axis: number;
        }, axis: number | {
            arr: ArrOrAny;
        } & {
            obj: ArrOrAny;
        } & {
            axis: number;
        }]

      Returns NDArray

insert

insert: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            arr: ArrOrAny;
        } & {
            obj: ArrOrAny;
        } & {
            values: ArrOrAny;
        } & {
            axis: number;
        }
      • Rest ...rest: [obj: ArrOrAny | {
            arr: ArrOrAny;
        } & {
            obj: ArrOrAny;
        } & {
            values: ArrOrAny;
        } & {
            axis: number;
        }, values: ArrOrAny | {
            arr: ArrOrAny;
        } & {
            obj: ArrOrAny;
        } & {
            values: ArrOrAny;
        } & {
            axis: number;
        }, axis: number | {
            arr: ArrOrAny;
        } & {
            obj: ArrOrAny;
        } & {
            values: ArrOrAny;
        } & {
            axis: number;
        }]

      Returns NDArray

resize

resize: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            new_shape: number | number[];
        }
      • Rest ...rest: [new_shape: number | number[] | {
            a: ArrOrAny;
        } & {
            new_shape: number | number[];
        }]

      Returns NDArray

trim_zeros

trim_zeros: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            filt: ArrOrAny;
        } & {
            trim: string;
        } & {
            axis: number | number[];
        }
      • Rest ...rest: [trim: string | {
            filt: ArrOrAny;
        } & {
            trim: string;
        } & {
            axis: number | number[];
        }, axis: number | number[] | {
            filt: ArrOrAny;
        } & {
            trim: string;
        } & {
            axis: number | number[];
        }]

      Returns NDArray

Iteration

flatiter

flatiter: typeof flatiter

iterable

iterable: ((y) => boolean)

Type declaration

    • (y): boolean

    • Parameters

      • y: any

      Returns boolean

ndenumerate

ndenumerate: ((arr) => Generator<[number[], any]>)

Type declaration

nested_iters

nested_iters: ((op, axes) => any[])

Type declaration

    • (op, axes): any[]

    • Parameters

      Returns any[]

ndindex

nditer

Joining

block

block: ((a, ...rest) => NDArray)

Type declaration

column_stack

column_stack: ((a, ...rest) => any)

Type declaration

    • (a, ...rest): any

    • Parameters

      Returns any

concat

concat: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: NDArray[] | {
            arrays: NDArray[];
        } & {
            axis: number;
        }
      • Rest ...rest: [axis: number | {
            arrays: NDArray[];
        } & {
            axis: number;
        }]

      Returns NDArray

dstack

dstack: ((a, ...rest) => any)

Type declaration

    • (a, ...rest): any

    • Parameters

      Returns any

hstack

hstack: ((a, ...rest) => any)

Type declaration

    • (a, ...rest): any

    • Parameters

      Returns any

vstack

vstack: ((a, ...rest) => any)

Type declaration

    • (a, ...rest): any

    • Parameters

      Returns any

Linear algebra

dot

dot: ((a, ...rest) => NDArray)

Type declaration

einsum

einsum: ((a, ...rest) => any) & ((...args) => any)

Type declaration

    • (a, ...rest): any

    • Parameters

      • a: string | {
            subscripts: string;
        } & {
            operands: any[];
        } & {
            dtype: ArrOrAny;
        } & {
            out: ArrOrAny;
        }
      • Rest ...rest: [operands: any[] | {
            subscripts: string;
        } & {
            operands: any[];
        } & {
            dtype: ArrOrAny;
        } & {
            out: ArrOrAny;
        }, dtype: ArrOrAny | {
            subscripts: string;
        } & {
            operands: any[];
        } & {
            dtype: ArrOrAny;
        } & {
            out: ArrOrAny;
        }, out: ArrOrAny | {
            subscripts: string;
        } & {
            operands: any[];
        } & {
            dtype: ArrOrAny;
        } & {
            out: ArrOrAny;
        }]

      Returns any

Type declaration

    • (...args): any

    • Parameters

      • Rest ...args: any[]

      Returns any

inner

inner: ((a, ...rest) => NDArray)

Type declaration

kron

kron: ((a, ...rest) => NDArray)

Type declaration

linalg

linalg: {
    LinAlgError: typeof LinAlgError;
    cholesky: ((a, ...rest) => NDArray);
    cond: ((a, ...rest) => NDArray);
    cross: ((a, ...rest) => any);
    det: ((a, ...rest) => any);
    diagonal: ((a, ...rest) => NDArray);
    eig: ((a, ...rest) => any);
    eigh: ((a, ...rest) => NDArray[]);
    eigvals: ((a, ...rest) => any);
    eigvalsh: ((a, ...rest) => NDArray);
    inv: ((a, ...rest) => any);
    lstsq: ((a, ...rest) => NDArray[]);
    matmul: ((a, ...rest) => NDArray);
    matrix_norm: ((a, ...rest) => NDArray);
    matrix_power: ((a, ...rest) => NDArray);
    matrix_rank: ((a, ...rest) => NDArray);
    matrix_transpose: ((a, ...rest) => NDArray);
    multi_dot: ((a, ...rest) => NDArray);
    norm: ((a, ...rest) => NDArray);
    outer: ((a, ...rest) => NDArray);
    pinv: ((a, ...rest) => NDArray);
    qr: ((a, ...rest) => NDArray | NDArray[]);
    slogdet: ((a, ...rest) => any);
    solve: ((a, ...rest) => NDArray);
    svd: ((a, ...rest) => NDArray | NDArray[]);
    svdvals: ((a, ...rest) => any);
    tensordot: ((a, ...rest) => NDArray);
    tensorinv: ((a, ...rest) => NDArray);
    tensorsolve: ((a, ...rest) => NDArray);
    trace: ((a, ...rest) => NDArray);
    vecdot: ((a, ...rest) => NDArray);
    vector_norm: ((a, ...rest) => NDArray);
}

numpy.linalg: linear algebra on stacks of matrices (real numbers only)

Type declaration

  • LinAlgError: typeof LinAlgError
  • cholesky: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              upper: boolean;
          }
        • Rest ...rest: [upper: boolean | {
              a: ArrOrAny;
          } & {
              upper: boolean;
          }]

        Returns NDArray

  • cond: ((a, ...rest) => NDArray)
  • cross: ((a, ...rest) => any)
      • (a, ...rest): any

      • Parameters

        • a: ArrOrAny | {
              x1: ArrOrAny;
          } & {
              x2: ArrOrAny;
          } & {
              axis: number;
          }
        • Rest ...rest: [b: ArrOrAny | {
              x1: ArrOrAny;
          } & {
              x2: ArrOrAny;
          } & {
              axis: number;
          }, axis: number | {
              x1: ArrOrAny;
          } & {
              x2: ArrOrAny;
          } & {
              axis: number;
          }]

        Returns any

  • det: ((a, ...rest) => any)
      • (a, ...rest): any

      • Parameters

        Returns any

  • diagonal: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              offset: number;
          } & {
              axis1: number;
          } & {
              axis2: number;
          }
        • Rest ...rest: [offset: number | {
              a: ArrOrAny;
          } & {
              offset: number;
          } & {
              axis1: number;
          } & {
              axis2: number;
          }, axis1: number | {
              a: ArrOrAny;
          } & {
              offset: number;
          } & {
              axis1: number;
          } & {
              axis2: number;
          }, axis2: number | {
              a: ArrOrAny;
          } & {
              offset: number;
          } & {
              axis1: number;
          } & {
              axis2: number;
          }]

        Returns NDArray

  • eig: ((a, ...rest) => any)
      • (a, ...rest): any

      • Parameters

        Returns any

  • eigh: ((a, ...rest) => NDArray[])
      • (a, ...rest): NDArray[]

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              UPLO: string;
          }
        • Rest ...rest: [UPLO: string | {
              a: ArrOrAny;
          } & {
              UPLO: string;
          }]

        Returns NDArray[]

  • eigvals: ((a, ...rest) => any)
      • (a, ...rest): any

      • Parameters

        Returns any

  • eigvalsh: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              UPLO: string;
          }
        • Rest ...rest: [UPLO: string | {
              a: ArrOrAny;
          } & {
              UPLO: string;
          }]

        Returns NDArray

  • inv: ((a, ...rest) => any)
      • (a, ...rest): any

      • Parameters

        Returns any

  • lstsq: ((a, ...rest) => NDArray[])
      • (a, ...rest): NDArray[]

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              b: ArrOrAny;
          } & {
              rcond: number;
          }
        • Rest ...rest: [b: ArrOrAny | {
              a: ArrOrAny;
          } & {
              b: ArrOrAny;
          } & {
              rcond: number;
          }, rcond: number | {
              a: ArrOrAny;
          } & {
              b: ArrOrAny;
          } & {
              rcond: number;
          }]

        Returns NDArray[]

  • matmul: ((a, ...rest) => NDArray)
  • matrix_norm: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              x: ArrOrAny;
          } & {
              ord: string | number;
          } & {
              keepdims: boolean;
          }
        • Rest ...rest: [ord: string | number | {
              x: ArrOrAny;
          } & {
              ord: string | number;
          } & {
              keepdims: boolean;
          }, keepdims: boolean | {
              x: ArrOrAny;
          } & {
              ord: string | number;
          } & {
              keepdims: boolean;
          }]

        Returns NDArray

  • matrix_power: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              n: number;
          }
        • Rest ...rest: [n: number | {
              a: ArrOrAny;
          } & {
              n: number;
          }]

        Returns NDArray

  • matrix_rank: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              A: ArrOrAny;
          } & {
              tol: number;
          } & {
              hermitian: boolean;
          } & {
              rtol: number;
          }
        • Rest ...rest: [tol: number | {
              A: ArrOrAny;
          } & {
              tol: number;
          } & {
              hermitian: boolean;
          } & {
              rtol: number;
          }, hermitian: boolean | {
              A: ArrOrAny;
          } & {
              tol: number;
          } & {
              hermitian: boolean;
          } & {
              rtol: number;
          }, rtol: number | {
              A: ArrOrAny;
          } & {
              tol: number;
          } & {
              hermitian: boolean;
          } & {
              rtol: number;
          }]

        Returns NDArray

  • matrix_transpose: ((a, ...rest) => NDArray)
  • multi_dot: ((a, ...rest) => NDArray)
  • norm: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              x: ArrOrAny;
          } & {
              ord: string | number;
          } & {
              axis: number | number[];
          } & {
              keepdims: boolean;
          }
        • Rest ...rest: [ord: string | number | {
              x: ArrOrAny;
          } & {
              ord: string | number;
          } & {
              axis: number | number[];
          } & {
              keepdims: boolean;
          }, axis: number | number[] | {
              x: ArrOrAny;
          } & {
              ord: string | number;
          } & {
              axis: number | number[];
          } & {
              keepdims: boolean;
          }, keepdims: boolean | {
              x: ArrOrAny;
          } & {
              ord: string | number;
          } & {
              axis: number | number[];
          } & {
              keepdims: boolean;
          }]

        Returns NDArray

  • outer: ((a, ...rest) => NDArray)
  • pinv: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              rcond: number | NDArray;
          } & {
              hermitian: boolean;
          } & {
              rtol: number;
          }
        • Rest ...rest: [rcond: number | NDArray | {
              a: ArrOrAny;
          } & {
              rcond: number | NDArray;
          } & {
              hermitian: boolean;
          } & {
              rtol: number;
          }, hermitian: boolean | {
              a: ArrOrAny;
          } & {
              rcond: number | NDArray;
          } & {
              hermitian: boolean;
          } & {
              rtol: number;
          }, rtol: number | {
              a: ArrOrAny;
          } & {
              rcond: number | NDArray;
          } & {
              hermitian: boolean;
          } & {
              rtol: number;
          }]

        Returns NDArray

  • qr: ((a, ...rest) => NDArray | NDArray[])
      • (a, ...rest): NDArray | NDArray[]

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              mode: "raw" | "r" | "complete" | "reduced";
          }
        • Rest ...rest: [mode: "raw" | "r" | "complete" | "reduced" | {
              a: ArrOrAny;
          } & {
              mode: "raw" | "r" | "complete" | "reduced";
          }]

        Returns NDArray | NDArray[]

  • slogdet: ((a, ...rest) => any)
      • (a, ...rest): any

      • Parameters

        Returns any

  • solve: ((a, ...rest) => NDArray)
  • svd: ((a, ...rest) => NDArray | NDArray[])
      • (a, ...rest): NDArray | NDArray[]

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              full_matrices: boolean;
          } & {
              compute_uv: boolean;
          } & {
              hermitian: boolean;
          }
        • Rest ...rest: [full_matrices: boolean | {
              a: ArrOrAny;
          } & {
              full_matrices: boolean;
          } & {
              compute_uv: boolean;
          } & {
              hermitian: boolean;
          }, compute_uv: boolean | {
              a: ArrOrAny;
          } & {
              full_matrices: boolean;
          } & {
              compute_uv: boolean;
          } & {
              hermitian: boolean;
          }, hermitian: boolean | {
              a: ArrOrAny;
          } & {
              full_matrices: boolean;
          } & {
              compute_uv: boolean;
          } & {
              hermitian: boolean;
          }]

        Returns NDArray | NDArray[]

  • svdvals: ((a, ...rest) => any)
      • (a, ...rest): any

      • Parameters

        Returns any

  • tensordot: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              b: ArrOrAny;
          } & {
              axes: number | [number | number[], number | number[]];
          }
        • Rest ...rest: [b: ArrOrAny | {
              a: ArrOrAny;
          } & {
              b: ArrOrAny;
          } & {
              axes: number | [number | number[], number | number[]];
          }, axes: number | [number | number[], number | number[]] | {
              a: ArrOrAny;
          } & {
              b: ArrOrAny;
          } & {
              axes: number | [number | number[], number | number[]];
          }]

        Returns NDArray

  • tensorinv: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              ind: number;
          }
        • Rest ...rest: [ind: number | {
              a: ArrOrAny;
          } & {
              ind: number;
          }]

        Returns NDArray

  • tensorsolve: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              b: ArrOrAny;
          } & {
              axes: number[];
          }
        • Rest ...rest: [b: ArrOrAny | {
              a: ArrOrAny;
          } & {
              b: ArrOrAny;
          } & {
              axes: number[];
          }, axes: number[] | {
              a: ArrOrAny;
          } & {
              b: ArrOrAny;
          } & {
              axes: number[];
          }]

        Returns NDArray

  • trace: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              offset: number;
          } & {
              axis1: number;
          } & {
              axis2: number;
          } & {
              dtype: DType;
          } & {
              out: ArrOrAny;
          }
        • Rest ...rest: [offset: number | {
              a: ArrOrAny;
          } & {
              offset: number;
          } & {
              axis1: number;
          } & {
              axis2: number;
          } & {
              dtype: DType;
          } & {
              out: ArrOrAny;
          }, axis1: number | {
              a: ArrOrAny;
          } & {
              offset: number;
          } & {
              axis1: number;
          } & {
              axis2: number;
          } & {
              dtype: DType;
          } & {
              out: ArrOrAny;
          }, axis2: number | {
              a: ArrOrAny;
          } & {
              offset: number;
          } & {
              axis1: number;
          } & {
              axis2: number;
          } & {
              dtype: DType;
          } & {
              out: ArrOrAny;
          }, dtype: DType | {
              a: ArrOrAny;
          } & {
              offset: number;
          } & {
              axis1: number;
          } & {
              axis2: number;
          } & {
              dtype: DType;
          } & {
              out: ArrOrAny;
          }, out: ArrOrAny | {
              a: ArrOrAny;
          } & {
              offset: number;
          } & {
              axis1: number;
          } & {
              axis2: number;
          } & {
              dtype: DType;
          } & {
              out: ArrOrAny;
          }]

        Returns NDArray

  • vecdot: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              x1: ArrOrAny;
          } & {
              x2: ArrOrAny;
          } & {
              axis: number;
          }
        • Rest ...rest: [x2: ArrOrAny | {
              x1: ArrOrAny;
          } & {
              x2: ArrOrAny;
          } & {
              axis: number;
          }, axis: number | {
              x1: ArrOrAny;
          } & {
              x2: ArrOrAny;
          } & {
              axis: number;
          }]

        Returns NDArray

  • vector_norm: ((a, ...rest) => NDArray)
      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              x: ArrOrAny;
          } & {
              axis: number | number[];
          } & {
              keepdims: boolean;
          } & {
              ord: number;
          }
        • Rest ...rest: [axis: number | number[] | {
              x: ArrOrAny;
          } & {
              axis: number | number[];
          } & {
              keepdims: boolean;
          } & {
              ord: number;
          }, keepdims: boolean | {
              x: ArrOrAny;
          } & {
              axis: number | number[];
          } & {
              keepdims: boolean;
          } & {
              ord: number;
          }, ord: number | {
              x: ArrOrAny;
          } & {
              axis: number | number[];
          } & {
              keepdims: boolean;
          } & {
              ord: number;
          }]

        Returns NDArray

matmul

matmul: ((a, ...rest) => NDArray)

Type declaration

matvec

matvec: ((a, ...rest) => NDArray)

Type declaration

outer

outer: ((a, ...rest) => NDArray)

Type declaration

tensordot

tensordot: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            b: ArrOrAny;
        } & {
            axes: number | [number | number[], number | number[]];
        }
      • Rest ...rest: [b: ArrOrAny | {
            a: ArrOrAny;
        } & {
            b: ArrOrAny;
        } & {
            axes: number | [number | number[], number | number[]];
        }, axes: number | [number | number[], number | number[]] | {
            a: ArrOrAny;
        } & {
            b: ArrOrAny;
        } & {
            axes: number | [number | number[], number | number[]];
        }]

      Returns NDArray

trace

trace: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            a: ArrOrAny;
        } & {
            offset: number;
        } & {
            axis1: number;
        } & {
            axis2: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }
      • Rest ...rest: [offset: number | {
            a: ArrOrAny;
        } & {
            offset: number;
        } & {
            axis1: number;
        } & {
            axis2: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }, axis1: number | {
            a: ArrOrAny;
        } & {
            offset: number;
        } & {
            axis1: number;
        } & {
            axis2: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }, axis2: number | {
            a: ArrOrAny;
        } & {
            offset: number;
        } & {
            axis1: number;
        } & {
            axis2: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }, dtype: DType | {
            a: ArrOrAny;
        } & {
            offset: number;
        } & {
            axis1: number;
        } & {
            axis2: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }, out: ArrOrAny | {
            a: ArrOrAny;
        } & {
            offset: number;
        } & {
            axis1: number;
        } & {
            axis2: number;
        } & {
            dtype: DType;
        } & {
            out: ArrOrAny;
        }]

      Returns NDArray

vdot

vdot: ((a, ...rest) => NDArray)

Type declaration

vecdot

vecdot: ((a, ...rest) => NDArray)

Type declaration

    • (a, ...rest): NDArray

    • Parameters

      • a: ArrOrAny | {
            x1: ArrOrAny;
        } & {
            x2: ArrOrAny;
        } & {
            axis: number;
        }
      • Rest ...rest: [x2: ArrOrAny | {
            x1: ArrOrAny;
        } & {
            x2: ArrOrAny;
        } & {
            axis: number;
        }, axis: number | {
            x1: ArrOrAny;
        } & {
            x2: ArrOrAny;
        } & {
            axis: number;
        }]

      Returns NDArray

vecmat

vecmat: ((a, ...rest) => NDArray)

Type declaration

einsum_path

  • einsum_path(subscripts, ...operands): [any[], string]

  • Parameters

    • subscripts: string
    • Rest ...operands: any[]

    Returns [any[], string]

Main

NDArray

NDArray: typeof NDArray

Namespace modules

modules: {
    array: any;
    constructors: any;
    grammar: any;
    indexing: any;
    random: any;
    statistics: any;
}

Type declaration

    Math

    convolve

    convolve: ((a, ...rest) => NDArray)

    Type declaration

    cross

    cross: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              b: ArrOrAny;
          } & {
              axisa: number;
          } & {
              axisb: number;
          } & {
              axisc: number;
          } & {
              axis: number;
          }
        • Rest ...rest: [b: ArrOrAny | {
              a: ArrOrAny;
          } & {
              b: ArrOrAny;
          } & {
              axisa: number;
          } & {
              axisb: number;
          } & {
              axisc: number;
          } & {
              axis: number;
          }, axisa: number | {
              a: ArrOrAny;
          } & {
              b: ArrOrAny;
          } & {
              axisa: number;
          } & {
              axisb: number;
          } & {
              axisc: number;
          } & {
              axis: number;
          }, axisb: number | {
              a: ArrOrAny;
          } & {
              b: ArrOrAny;
          } & {
              axisa: number;
          } & {
              axisb: number;
          } & {
              axisc: number;
          } & {
              axis: number;
          }, axisc: number | {
              a: ArrOrAny;
          } & {
              b: ArrOrAny;
          } & {
              axisa: number;
          } & {
              axisb: number;
          } & {
              axisc: number;
          } & {
              axis: number;
          }, axis: number | {
              a: ArrOrAny;
          } & {
              b: ArrOrAny;
          } & {
              axisa: number;
          } & {
              axisb: number;
          } & {
              axisc: number;
          } & {
              axis: number;
          }]

        Returns NDArray

    emath

    emath: {
        arccos: ((x) => NDArray);
        arcsin: ((x) => NDArray);
        arctanh: ((x) => NDArray);
        log: ((x) => NDArray);
        log10: ((x) => NDArray);
        log2: ((x) => NDArray);
        logn: ((n, x) => NDArray);
        power: ((x, p) => NDArray);
        sqrt: ((x) => NDArray);
    }

    Mathematical functions with automatic domain: results must be real (complex numbers are not supported).

    Type declaration

    interp

    interp: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              x: ArrOrAny;
          } & {
              xp: ArrOrAny;
          } & {
              fp: ArrOrAny;
          } & {
              left: number;
          } & {
              right: number;
          } & {
              period: number;
          }
        • Rest ...rest: [xp: ArrOrAny | {
              x: ArrOrAny;
          } & {
              xp: ArrOrAny;
          } & {
              fp: ArrOrAny;
          } & {
              left: number;
          } & {
              right: number;
          } & {
              period: number;
          }, fp: ArrOrAny | {
              x: ArrOrAny;
          } & {
              xp: ArrOrAny;
          } & {
              fp: ArrOrAny;
          } & {
              left: number;
          } & {
              right: number;
          } & {
              period: number;
          }, left: number | {
              x: ArrOrAny;
          } & {
              xp: ArrOrAny;
          } & {
              fp: ArrOrAny;
          } & {
              left: number;
          } & {
              right: number;
          } & {
              period: number;
          }, right: number | {
              x: ArrOrAny;
          } & {
              xp: ArrOrAny;
          } & {
              fp: ArrOrAny;
          } & {
              left: number;
          } & {
              right: number;
          } & {
              period: number;
          }, period: number | {
              x: ArrOrAny;
          } & {
              xp: ArrOrAny;
          } & {
              fp: ArrOrAny;
          } & {
              left: number;
          } & {
              right: number;
          } & {
              period: number;
          }]

        Returns NDArray

    trapezoid

    trapezoid: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              y: ArrOrAny;
          } & {
              x: ArrOrAny;
          } & {
              dx: number;
          } & {
              axis: number;
          }
        • Rest ...rest: [x: ArrOrAny | {
              y: ArrOrAny;
          } & {
              x: ArrOrAny;
          } & {
              dx: number;
          } & {
              axis: number;
          }, dx: number | {
              y: ArrOrAny;
          } & {
              x: ArrOrAny;
          } & {
              dx: number;
          } & {
              axis: number;
          }, axis: number | {
              y: ArrOrAny;
          } & {
              x: ArrOrAny;
          } & {
              dx: number;
          } & {
              axis: number;
          }]

        Returns NDArray

    unwrap

    unwrap: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              p: ArrOrAny;
          } & {
              discont: number;
          } & {
              axis: number;
          } & {
              period: number;
          }
        • Rest ...rest: [discont: number | {
              p: ArrOrAny;
          } & {
              discont: number;
          } & {
              axis: number;
          } & {
              period: number;
          }, axis: number | {
              p: ArrOrAny;
          } & {
              discont: number;
          } & {
              axis: number;
          } & {
              period: number;
          }, period: number | {
              p: ArrOrAny;
          } & {
              discont: number;
          } & {
              axis: number;
          } & {
              period: number;
          }]

        Returns NDArray

    Math constants

    e

    e: number

    euler_gamma

    euler_gamma: number

    inf

    inf: number

    nan

    nan: number

    newaxis

    newaxis: any

    pi

    pi: number

    Memory

    may_share_memory

    may_share_memory: ((a, b, max_work?) => boolean)

    Type declaration

      • (a, b, max_work?): boolean

      • Parameters

        Returns boolean

    shares_memory

    shares_memory: ((a, b, max_work?) => boolean)

    Type declaration

      • (a, b, max_work?): boolean

      • Parameters

        Returns boolean

    Modules

    random

    random: "/home/runner/work/ndarray-js/ndarray-js/src/modules/random"

    Other

    DataSource

    DataSource: typeof DataSource

    False_

    False_: boolean

    True_

    True_: boolean

    absolute

    absolute: Wrapper

    amax

    amax: Wrapper

    amin

    amin: Wrapper

    arccos

    arccos: Wrapper

    arccosh

    arccosh: Wrapper

    arcsin

    arcsin: Wrapper

    arcsinh

    arcsinh: Wrapper

    arctan

    arctan: Wrapper

    arctanh

    arctanh: Wrapper

    assign

    assign: ((a, values, where) => NDArray)

    Type declaration

    busday_count

    busday_count: ((a, ...rest) => any)

    Type declaration

    busday_offset

    busday_offset: ((a, ...rest) => any)

    Type declaration

      • (a, ...rest): any

      • Parameters

        • a: ArrOrAny | {
              dates: ArrOrAny;
          } & {
              offsets: ArrOrAny;
          } & {
              roll: string;
          } & {
              weekmask: ArrOrAny;
          } & {
              holidays: ArrOrAny;
          } & {
              busdaycal: ArrOrAny;
          } & {
              out: ArrOrAny;
          }
        • Rest ...rest: [offsets: ArrOrAny | {
              dates: ArrOrAny;
          } & {
              offsets: ArrOrAny;
          } & {
              roll: string;
          } & {
              weekmask: ArrOrAny;
          } & {
              holidays: ArrOrAny;
          } & {
              busdaycal: ArrOrAny;
          } & {
              out: ArrOrAny;
          }, roll: string | {
              dates: ArrOrAny;
          } & {
              offsets: ArrOrAny;
          } & {
              roll: string;
          } & {
              weekmask: ArrOrAny;
          } & {
              holidays: ArrOrAny;
          } & {
              busdaycal: ArrOrAny;
          } & {
              out: ArrOrAny;
          }, weekmask: ArrOrAny | {
              dates: ArrOrAny;
          } & {
              offsets: ArrOrAny;
          } & {
              roll: string;
          } & {
              weekmask: ArrOrAny;
          } & {
              holidays: ArrOrAny;
          } & {
              busdaycal: ArrOrAny;
          } & {
              out: ArrOrAny;
          }]

        Returns any

    busdaycalendar

    busdaycalendar: ((...args) => busdaycalendar)

    Type declaration

    datetime_as_string

    datetime_as_string: ((a, ...rest) => any)

    Type declaration

      • (a, ...rest): any

      • Parameters

        • a: ArrOrAny | {
              arr: ArrOrAny;
          } & {
              unit: string;
          } & {
              timezone: string;
          } & {
              casting: string;
          }
        • Rest ...rest: [unit: string | {
              arr: ArrOrAny;
          } & {
              unit: string;
          } & {
              timezone: string;
          } & {
              casting: string;
          }, timezone: string | {
              arr: ArrOrAny;
          } & {
              unit: string;
          } & {
              timezone: string;
          } & {
              casting: string;
          }, casting: string | {
              arr: ArrOrAny;
          } & {
              unit: string;
          } & {
              timezone: string;
          } & {
              casting: string;
          }]

        Returns any

    datetime_data

    datetime_data: ((dtype) => [string, number])

    Type declaration

      • (dtype): [string, number]

      • Parameters

        • dtype: any

        Returns [string, number]

    fabs

    fabs: Wrapper

    is_busday

    is_busday: ((a, ...rest) => any)

    Type declaration

    isnat

    isnat: ((x) => any)

    Type declaration

      • (x): any

      • Parameters

        • x: any

        Returns any

    little_endian

    little_endian: boolean

    ndarray

    ndarray: typeof NDArray

    isfortran

    Padding

    pad

    pad: ((a, ...rest) => any)

    Type declaration

      • (a, ...rest): any

      • Parameters

        • a: ArrOrAny | {
              array: ArrOrAny;
          } & {
              pad_width: ArrOrAny;
          } & {
              mode: PadMode;
          } & {
              constant_values: ArrOrAny;
          } & {
              end_values: ArrOrAny;
          } & {
              stat_length: ArrOrAny;
          } & {
              reflect_type: ArrOrAny;
          }
        • Rest ...rest: [pad_width: ArrOrAny | {
              array: ArrOrAny;
          } & {
              pad_width: ArrOrAny;
          } & {
              mode: PadMode;
          } & {
              constant_values: ArrOrAny;
          } & {
              end_values: ArrOrAny;
          } & {
              stat_length: ArrOrAny;
          } & {
              reflect_type: ArrOrAny;
          }, mode: PadMode | {
              array: ArrOrAny;
          } & {
              pad_width: ArrOrAny;
          } & {
              mode: PadMode;
          } & {
              constant_values: ArrOrAny;
          } & {
              end_values: ArrOrAny;
          } & {
              stat_length: ArrOrAny;
          } & {
              reflect_type: ArrOrAny;
          }, constant_values: ArrOrAny | {
              array: ArrOrAny;
          } & {
              pad_width: ArrOrAny;
          } & {
              mode: PadMode;
          } & {
              constant_values: ArrOrAny;
          } & {
              end_values: ArrOrAny;
          } & {
              stat_length: ArrOrAny;
          } & {
              reflect_type: ArrOrAny;
          }]

        Returns any

    Polynomials

    poly

    poly: ((...args) => any)

    Type declaration

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

    poly1d

    poly1d: typeof poly1d

    Polynomial with the coefficients in decreasing powers (numpy.poly1d)

    polyadd

    polyadd: ((...args) => any)

    Type declaration

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

    polyder

    polyder: ((...args) => any)

    Type declaration

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

    polydiv

    polydiv: ((...args) => any)

    Type declaration

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

    polyfit

    polyfit: ((...args) => any)

    Type declaration

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

    polyint

    polyint: ((...args) => any)

    Type declaration

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

    polymul

    polymul: ((...args) => any)

    Type declaration

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

    polynomial

    polynomial: {
        [name: string]: any;
    }

    numpy.polynomial: power series and Chebyshev, Hermite, HermiteE, Laguerre and Legendre series

    Type declaration

    • [name: string]: any

    polysub

    polysub: ((...args) => any)

    Type declaration

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

    polyval

    polyval: ((...args) => any)

    Type declaration

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

    roots

    roots: ((...args) => any)

    Type declaration

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

    Reducers

    all

    all: Wrapper

    any

    any: Wrapper

    argmax

    argmax: Wrapper

    argmin

    argmin: Wrapper

    count_nonzero

    count_nonzero: Wrapper

    len

    len: Wrapper

    max

    max: Wrapper

    mean

    mean: Wrapper

    min

    min: Wrapper

    nanargmax

    nanargmax: Wrapper

    nanargmin

    nanargmin: Wrapper

    nanmax

    nanmax: Wrapper

    nanmean

    nanmean: Wrapper

    nanmin

    nanmin: Wrapper

    nanprod

    nanprod: Wrapper

    nanstd

    nanstd: Wrapper

    nansum

    nansum: Wrapper

    nanvar

    nanvar: Wrapper

    norm

    norm: Wrapper

    prod

    prod: Wrapper

    product

    product: Wrapper

    ptp

    ptp: Wrapper

    std

    std: Wrapper

    sum

    sum: Wrapper

    var

    var: Wrapper

    Reordering

    flip

    flip: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              m: ArrOrAny;
          } & {
              axis: number | number[];
          }
        • Rest ...rest: [axis: number | number[] | {
              m: ArrOrAny;
          } & {
              axis: number | number[];
          }]

        Returns NDArray

    fliplr

    fliplr: ((a, ...rest) => NDArray)

    Type declaration

    flipud

    flipud: ((a, ...rest) => NDArray)

    Type declaration

    roll

    roll: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              shift: number | number[];
          } & {
              axis: number | number[];
          }
        • Rest ...rest: [shift: number | number[] | {
              a: ArrOrAny;
          } & {
              shift: number | number[];
          } & {
              axis: number | number[];
          }, axis: number | number[] | {
              a: ArrOrAny;
          } & {
              shift: number | number[];
          } & {
              axis: number | number[];
          }]

        Returns NDArray

    rot90

    rot90: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              m: ArrOrAny;
          } & {
              k: number;
          } & {
              axes: number[];
          }
        • Rest ...rest: [k: number | {
              m: ArrOrAny;
          } & {
              k: number;
          } & {
              axes: number[];
          }, axes: number[] | {
              m: ArrOrAny;
          } & {
              k: number;
          } & {
              axes: number[];
          }]

        Returns NDArray

    Repeating

    repeat

    repeat: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              repeats: number | number[] | NDArray;
          } & {
              axis: number;
          }
        • Rest ...rest: [repeats: number | number[] | NDArray | {
              a: ArrOrAny;
          } & {
              repeats: number | number[] | NDArray;
          } & {
              axis: number;
          }, axis: number | {
              a: ArrOrAny;
          } & {
              repeats: number | number[] | NDArray;
          } & {
              axis: number;
          }]

        Returns NDArray

    tile

    tile: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              A: ArrOrAny;
          } & {
              reps: number | number[];
          }
        • Rest ...rest: [reps: number | number[] | {
              A: ArrOrAny;
          } & {
              reps: number | number[];
          }]

        Returns NDArray

    Searching

    argwhere

    argwhere: ((a, ...rest) => NDArray)

    Type declaration

    extract

    extract: ((a, ...rest) => NDArray)

    Type declaration

    flatnonzero

    flatnonzero: ((a, ...rest) => NDArray)

    Type declaration

    nonzero

    nonzero: ((a, ...rest) => NDArray)

    Type declaration

    searchsorted

    searchsorted: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              v: ArrOrAny;
          } & {
              side: "left" | "right";
          } & {
              sorter: ArrOrAny;
          }
        • Rest ...rest: [v: ArrOrAny | {
              a: ArrOrAny;
          } & {
              v: ArrOrAny;
          } & {
              side: "left" | "right";
          } & {
              sorter: ArrOrAny;
          }, side: "left" | "right" | {
              a: ArrOrAny;
          } & {
              v: ArrOrAny;
          } & {
              side: "left" | "right";
          } & {
              sorter: ArrOrAny;
          }, sorter: ArrOrAny | {
              a: ArrOrAny;
          } & {
              v: ArrOrAny;
          } & {
              side: "left" | "right";
          } & {
              sorter: ArrOrAny;
          }]

        Returns NDArray

    where

    where: ((a, ...rest) => any)

    Type declaration

    Sets

    group_by

    group_by: ((a, ...rest) => GroupBy)

    Type declaration

      • (a, ...rest): GroupBy

      • Parameters

        • a: ArrOrAny | {
              keys: ArrOrAny;
          } & {
              values: ArrOrAny;
          } & {
              axis: number;
          } & {
              func: ((group) => any);
          }
        • Rest ...rest: [values: ArrOrAny | {
              keys: ArrOrAny;
          } & {
              values: ArrOrAny;
          } & {
              axis: number;
          } & {
              func: ((group) => any);
          }, axis: number | {
              keys: ArrOrAny;
          } & {
              values: ArrOrAny;
          } & {
              axis: number;
          } & {
              func: ((group) => any);
          }, func: ((group) => any) | {
              keys: ArrOrAny;
          } & {
              values: ArrOrAny;
          } & {
              axis: number;
          } & {
              func: ((group) => any);
          }]

        Returns GroupBy

    intersect1d

    intersect1d: ((a, ...rest) => NDArray | NDArray[])

    Type declaration

      • (a, ...rest): NDArray | NDArray[]

      • Parameters

        • a: ArrOrAny | {
              ar1: ArrOrAny;
          } & {
              ar2: ArrOrAny;
          } & {
              assume_unique: boolean;
          } & {
              return_indices: boolean;
          }
        • Rest ...rest: [ar2: ArrOrAny | {
              ar1: ArrOrAny;
          } & {
              ar2: ArrOrAny;
          } & {
              assume_unique: boolean;
          } & {
              return_indices: boolean;
          }, assume_unique: boolean | {
              ar1: ArrOrAny;
          } & {
              ar2: ArrOrAny;
          } & {
              assume_unique: boolean;
          } & {
              return_indices: boolean;
          }, return_indices: boolean | {
              ar1: ArrOrAny;
          } & {
              ar2: ArrOrAny;
          } & {
              assume_unique: boolean;
          } & {
              return_indices: boolean;
          }]

        Returns NDArray | NDArray[]

    isin

    isin: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              element: ArrOrAny;
          } & {
              test_elements: ArrOrAny;
          } & {
              assume_unique: boolean;
          } & {
              invert: boolean;
          } & {
              kind: string;
          }
        • Rest ...rest: [test_elements: ArrOrAny | {
              element: ArrOrAny;
          } & {
              test_elements: ArrOrAny;
          } & {
              assume_unique: boolean;
          } & {
              invert: boolean;
          } & {
              kind: string;
          }, assume_unique: boolean | {
              element: ArrOrAny;
          } & {
              test_elements: ArrOrAny;
          } & {
              assume_unique: boolean;
          } & {
              invert: boolean;
          } & {
              kind: string;
          }, invert: boolean | {
              element: ArrOrAny;
          } & {
              test_elements: ArrOrAny;
          } & {
              assume_unique: boolean;
          } & {
              invert: boolean;
          } & {
              kind: string;
          }, kind: string | {
              element: ArrOrAny;
          } & {
              test_elements: ArrOrAny;
          } & {
              assume_unique: boolean;
          } & {
              invert: boolean;
          } & {
              kind: string;
          }]

        Returns NDArray

    setdiff1d

    setdiff1d: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              ar1: ArrOrAny;
          } & {
              ar2: ArrOrAny;
          } & {
              assume_unique: boolean;
          }
        • Rest ...rest: [ar2: ArrOrAny | {
              ar1: ArrOrAny;
          } & {
              ar2: ArrOrAny;
          } & {
              assume_unique: boolean;
          }, assume_unique: boolean | {
              ar1: ArrOrAny;
          } & {
              ar2: ArrOrAny;
          } & {
              assume_unique: boolean;
          }]

        Returns NDArray

    setxor1d

    setxor1d: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              ar1: ArrOrAny;
          } & {
              ar2: ArrOrAny;
          } & {
              assume_unique: boolean;
          }
        • Rest ...rest: [ar2: ArrOrAny | {
              ar1: ArrOrAny;
          } & {
              ar2: ArrOrAny;
          } & {
              assume_unique: boolean;
          }, assume_unique: boolean | {
              ar1: ArrOrAny;
          } & {
              ar2: ArrOrAny;
          } & {
              assume_unique: boolean;
          }]

        Returns NDArray

    union1d

    union1d: ((a, ...rest) => NDArray)

    Type declaration

    unique

    unique: ((a, ...rest) => NDArray | NDArray[])

    Type declaration

      • (a, ...rest): NDArray | NDArray[]

      • Parameters

        • a: ArrOrAny | {
              ar: ArrOrAny;
          } & {
              return_index: boolean;
          } & {
              return_inverse: boolean;
          } & {
              return_counts: boolean;
          } & {
              axis: number;
          } & {
              equal_nan: boolean;
          }
        • Rest ...rest: [return_index: boolean | {
              ar: ArrOrAny;
          } & {
              return_index: boolean;
          } & {
              return_inverse: boolean;
          } & {
              return_counts: boolean;
          } & {
              axis: number;
          } & {
              equal_nan: boolean;
          }, return_inverse: boolean | {
              ar: ArrOrAny;
          } & {
              return_index: boolean;
          } & {
              return_inverse: boolean;
          } & {
              return_counts: boolean;
          } & {
              axis: number;
          } & {
              equal_nan: boolean;
          }, return_counts: boolean | {
              ar: ArrOrAny;
          } & {
              return_index: boolean;
          } & {
              return_inverse: boolean;
          } & {
              return_counts: boolean;
          } & {
              axis: number;
          } & {
              equal_nan: boolean;
          }, axis: number | {
              ar: ArrOrAny;
          } & {
              return_index: boolean;
          } & {
              return_inverse: boolean;
          } & {
              return_counts: boolean;
          } & {
              axis: number;
          } & {
              equal_nan: boolean;
          }, equal_nan: boolean | {
              ar: ArrOrAny;
          } & {
              return_index: boolean;
          } & {
              return_inverse: boolean;
          } & {
              return_counts: boolean;
          } & {
              axis: number;
          } & {
              equal_nan: boolean;
          }]

        Returns NDArray | NDArray[]

    unique_all

    unique_all: ((a, ...rest) => NDArray)

    Type declaration

    unique_counts

    unique_counts: ((a, ...rest) => NDArray)

    Type declaration

    unique_inverse

    unique_inverse: ((a, ...rest) => NDArray)

    Type declaration

    unique_values

    unique_values: ((a, ...rest) => NDArray)

    Type declaration

    Settings

    get_include

    get_include: (() => string)

    Type declaration

      • (): string

      • Returns string

    getbufsize

    getbufsize: (() => number)

    Type declaration

      • (): number

      • Returns number

    info

    info: ((obj?) => string)

    Type declaration

      • (obj?): string

      • Parameters

        • obj: any = null

        Returns string

    setbufsize

    setbufsize: ((size) => number)

    Type declaration

      • (size): number

      • Parameters

        • size: number

        Returns number

    show_config

    show_config: (() => {
        backend: string;
        dtypes: string[];
        language: string;
        name: string;
    })

    Type declaration

      • (): {
            backend: string;
            dtypes: string[];
            language: string;
            name: string;
        }

      • Returns {
            backend: string;
            dtypes: string[];
            language: string;
            name: string;
        }

        • backend: string
        • dtypes: string[]
        • language: string
        • name: string

    show_runtime

    show_runtime: (() => {
        backend: string;
        dtypes: string[];
        language: string;
        name: string;
        runtime: string;
    })

    Type declaration

      • (): {
            backend: string;
            dtypes: string[];
            language: string;
            name: string;
            runtime: string;
        }

      • Returns {
            backend: string;
            dtypes: string[];
            language: string;
            name: string;
            runtime: string;
        }

        • backend: string
        • dtypes: string[]
        • language: string
        • name: string
        • runtime: string

    Sorting

    argpartition

    argpartition: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              kth: number | number[];
          } & {
              axis: number;
          }
        • Rest ...rest: [kth: number | number[] | {
              a: ArrOrAny;
          } & {
              kth: number | number[];
          } & {
              axis: number;
          }, axis: number | {
              a: ArrOrAny;
          } & {
              kth: number | number[];
          } & {
              axis: number;
          }]

        Returns NDArray

    argsort

    argsort: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              axis: number;
          }
        • Rest ...rest: [axis: number | {
              a: ArrOrAny;
          } & {
              axis: number;
          }]

        Returns NDArray

    lexsort

    lexsort: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: NDArray[] | {
              keys: NDArray[];
          } & {
              axis: number;
          }
        • Rest ...rest: [axis: number | {
              keys: NDArray[];
          } & {
              axis: number;
          }]

        Returns NDArray

    partition

    partition: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              kth: number | number[];
          } & {
              axis: number;
          }
        • Rest ...rest: [kth: number | number[] | {
              a: ArrOrAny;
          } & {
              kth: number | number[];
          } & {
              axis: number;
          }, axis: number | {
              a: ArrOrAny;
          } & {
              kth: number | number[];
          } & {
              axis: number;
          }]

        Returns NDArray

    sort

    sort: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              axis: number;
          }
        • Rest ...rest: [axis: number | {
              a: ArrOrAny;
          } & {
              axis: number;
          }]

        Returns NDArray

    sort_complex

    • sort_complex(a): NDArray

    • Sorts along the last axis, with complex values: sorted by real part, then imaginary part.

      Parameters

      • a: any

      Returns NDArray

    Splitting

    array_split

    array_split: ((a, ...rest) => NDArray[])

    Type declaration

      • (a, ...rest): NDArray[]

      • Parameters

        • a: ArrOrAny | {
              ary: ArrOrAny;
          } & {
              indices_or_sections: number | number[];
          } & {
              axis: number;
          }
        • Rest ...rest: [ios: number | number[] | {
              ary: ArrOrAny;
          } & {
              indices_or_sections: number | number[];
          } & {
              axis: number;
          }, axis: number | {
              ary: ArrOrAny;
          } & {
              indices_or_sections: number | number[];
          } & {
              axis: number;
          }]

        Returns NDArray[]

    dsplit

    dsplit: ((a, ...rest) => NDArray[])

    Type declaration

      • (a, ...rest): NDArray[]

      • Parameters

        • a: ArrOrAny | {
              ary: ArrOrAny;
          } & {
              indices_or_sections: number | number[];
          }
        • Rest ...rest: [ios: number | number[] | {
              ary: ArrOrAny;
          } & {
              indices_or_sections: number | number[];
          }]

        Returns NDArray[]

    hsplit

    hsplit: ((a, ...rest) => NDArray[])

    Type declaration

      • (a, ...rest): NDArray[]

      • Parameters

        • a: ArrOrAny | {
              ary: ArrOrAny;
          } & {
              indices_or_sections: number | number[];
          }
        • Rest ...rest: [ios: number | number[] | {
              ary: ArrOrAny;
          } & {
              indices_or_sections: number | number[];
          }]

        Returns NDArray[]

    split

    split: ((a, ...rest) => NDArray[])

    Type declaration

      • (a, ...rest): NDArray[]

      • Parameters

        • a: ArrOrAny | {
              ary: ArrOrAny;
          } & {
              indices_or_sections: number | number[];
          } & {
              axis: number;
          }
        • Rest ...rest: [ios: number | number[] | {
              ary: ArrOrAny;
          } & {
              indices_or_sections: number | number[];
          } & {
              axis: number;
          }, axis: number | {
              ary: ArrOrAny;
          } & {
              indices_or_sections: number | number[];
          } & {
              axis: number;
          }]

        Returns NDArray[]

    unstack

    unstack: ((a, ...rest) => NDArray[])

    Type declaration

      • (a, ...rest): NDArray[]

      • Parameters

        • a: ArrOrAny | {
              x: ArrOrAny;
          } & {
              axis: number;
          }
        • Rest ...rest: [axis: number | {
              x: ArrOrAny;
          } & {
              axis: number;
          }]

        Returns NDArray[]

    vsplit

    vsplit: ((a, ...rest) => NDArray[])

    Type declaration

      • (a, ...rest): NDArray[]

      • Parameters

        • a: ArrOrAny | {
              ary: ArrOrAny;
          } & {
              indices_or_sections: number | number[];
          }
        • Rest ...rest: [ios: number | number[] | {
              ary: ArrOrAny;
          } & {
              indices_or_sections: number | number[];
          }]

        Returns NDArray[]

    Statistics

    average

    average: ((a, ...rest) => NDArray | NDArray[])

    Type declaration

      • (a, ...rest): NDArray | NDArray[]

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              axis: AxisArg;
          } & {
              weights: ArrOrAny;
          } & {
              returned: boolean;
          } & {
              keepdims: boolean;
          }
        • Rest ...rest: [axis: AxisArg | {
              a: ArrOrAny;
          } & {
              axis: AxisArg;
          } & {
              weights: ArrOrAny;
          } & {
              returned: boolean;
          } & {
              keepdims: boolean;
          }, weights: ArrOrAny | {
              a: ArrOrAny;
          } & {
              axis: AxisArg;
          } & {
              weights: ArrOrAny;
          } & {
              returned: boolean;
          } & {
              keepdims: boolean;
          }, returned: boolean | {
              a: ArrOrAny;
          } & {
              axis: AxisArg;
          } & {
              weights: ArrOrAny;
          } & {
              returned: boolean;
          } & {
              keepdims: boolean;
          }, keepdims: boolean | {
              a: ArrOrAny;
          } & {
              axis: AxisArg;
          } & {
              weights: ArrOrAny;
          } & {
              returned: boolean;
          } & {
              keepdims: boolean;
          }]

        Returns NDArray | NDArray[]

    corrcoef

    corrcoef: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              x: ArrOrAny;
          } & {
              y: ArrOrAny;
          } & {
              rowvar: boolean;
          }
        • Rest ...rest: [y: ArrOrAny | {
              x: ArrOrAny;
          } & {
              y: ArrOrAny;
          } & {
              rowvar: boolean;
          }, rowvar: boolean | {
              x: ArrOrAny;
          } & {
              y: ArrOrAny;
          } & {
              rowvar: boolean;
          }]

        Returns NDArray

    correlate

    correlate: ((a, ...rest) => NDArray)

    Type declaration

    cov

    cov: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              m: ArrOrAny;
          } & {
              y: ArrOrAny;
          } & {
              rowvar: boolean;
          } & {
              bias: boolean;
          } & {
              ddof: number;
          } & {
              fweights: ArrOrAny;
          } & {
              aweights: ArrOrAny;
          }
        • Rest ...rest: [y: ArrOrAny | {
              m: ArrOrAny;
          } & {
              y: ArrOrAny;
          } & {
              rowvar: boolean;
          } & {
              bias: boolean;
          } & {
              ddof: number;
          } & {
              fweights: ArrOrAny;
          } & {
              aweights: ArrOrAny;
          }, rowvar: boolean | {
              m: ArrOrAny;
          } & {
              y: ArrOrAny;
          } & {
              rowvar: boolean;
          } & {
              bias: boolean;
          } & {
              ddof: number;
          } & {
              fweights: ArrOrAny;
          } & {
              aweights: ArrOrAny;
          }, bias: boolean | {
              m: ArrOrAny;
          } & {
              y: ArrOrAny;
          } & {
              rowvar: boolean;
          } & {
              bias: boolean;
          } & {
              ddof: number;
          } & {
              fweights: ArrOrAny;
          } & {
              aweights: ArrOrAny;
          }]

        Returns NDArray

    median

    median: Wrapper

    nanmedian

    nanmedian: Wrapper

    nanpercentile

    nanpercentile: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              q: number | NDArray;
          } & {
              axis: AxisArg;
          } & {
              keepdims: boolean;
          } & {
              method: QuantileMethod;
          } & {
              out: ArrOrAny;
          }
        • Rest ...rest: [q: number | NDArray | {
              a: ArrOrAny;
          } & {
              q: number | NDArray;
          } & {
              axis: AxisArg;
          } & {
              keepdims: boolean;
          } & {
              method: QuantileMethod;
          } & {
              out: ArrOrAny;
          }, axis: AxisArg | {
              a: ArrOrAny;
          } & {
              q: number | NDArray;
          } & {
              axis: AxisArg;
          } & {
              keepdims: boolean;
          } & {
              method: QuantileMethod;
          } & {
              out: ArrOrAny;
          }, keepdims: boolean | {
              a: ArrOrAny;
          } & {
              q: number | NDArray;
          } & {
              axis: AxisArg;
          } & {
              keepdims: boolean;
          } & {
              method: QuantileMethod;
          } & {
              out: ArrOrAny;
          }]

        Returns NDArray

    nanquantile

    nanquantile: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              q: number | NDArray;
          } & {
              axis: AxisArg;
          } & {
              keepdims: boolean;
          } & {
              method: QuantileMethod;
          } & {
              out: ArrOrAny;
          }
        • Rest ...rest: [q: number | NDArray | {
              a: ArrOrAny;
          } & {
              q: number | NDArray;
          } & {
              axis: AxisArg;
          } & {
              keepdims: boolean;
          } & {
              method: QuantileMethod;
          } & {
              out: ArrOrAny;
          }, axis: AxisArg | {
              a: ArrOrAny;
          } & {
              q: number | NDArray;
          } & {
              axis: AxisArg;
          } & {
              keepdims: boolean;
          } & {
              method: QuantileMethod;
          } & {
              out: ArrOrAny;
          }, keepdims: boolean | {
              a: ArrOrAny;
          } & {
              q: number | NDArray;
          } & {
              axis: AxisArg;
          } & {
              keepdims: boolean;
          } & {
              method: QuantileMethod;
          } & {
              out: ArrOrAny;
          }]

        Returns NDArray

    percentile

    percentile: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              q: number | NDArray;
          } & {
              axis: AxisArg;
          } & {
              keepdims: boolean;
          } & {
              method: QuantileMethod;
          } & {
              out: ArrOrAny;
          }
        • Rest ...rest: [q: number | NDArray | {
              a: ArrOrAny;
          } & {
              q: number | NDArray;
          } & {
              axis: AxisArg;
          } & {
              keepdims: boolean;
          } & {
              method: QuantileMethod;
          } & {
              out: ArrOrAny;
          }, axis: AxisArg | {
              a: ArrOrAny;
          } & {
              q: number | NDArray;
          } & {
              axis: AxisArg;
          } & {
              keepdims: boolean;
          } & {
              method: QuantileMethod;
          } & {
              out: ArrOrAny;
          }, keepdims: boolean | {
              a: ArrOrAny;
          } & {
              q: number | NDArray;
          } & {
              axis: AxisArg;
          } & {
              keepdims: boolean;
          } & {
              method: QuantileMethod;
          } & {
              out: ArrOrAny;
          }]

        Returns NDArray

    quantile

    quantile: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              q: number | NDArray;
          } & {
              axis: AxisArg;
          } & {
              keepdims: boolean;
          } & {
              method: QuantileMethod;
          } & {
              out: ArrOrAny;
          }
        • Rest ...rest: [q: number | NDArray | {
              a: ArrOrAny;
          } & {
              q: number | NDArray;
          } & {
              axis: AxisArg;
          } & {
              keepdims: boolean;
          } & {
              method: QuantileMethod;
          } & {
              out: ArrOrAny;
          }, axis: AxisArg | {
              a: ArrOrAny;
          } & {
              q: number | NDArray;
          } & {
              axis: AxisArg;
          } & {
              keepdims: boolean;
          } & {
              method: QuantileMethod;
          } & {
              out: ArrOrAny;
          }, keepdims: boolean | {
              a: ArrOrAny;
          } & {
              q: number | NDArray;
          } & {
              axis: AxisArg;
          } & {
              keepdims: boolean;
          } & {
              method: QuantileMethod;
          } & {
              out: ArrOrAny;
          }]

        Returns NDArray

    Strings

    char

    char: {
        array: ((...args) => any);
        asarray: ((...args) => any);
        join: ((...args) => any);
        rsplit: ((...args) => any);
        split: ((...args) => any);
        splitlines: ((...args) => any);
    }

    Legacy string functions (numpy.char)

    Type declaration

    • array: ((...args) => any)
        • (...args): any

        • Parameters

          • Rest ...args: any[]

          Returns any

    • asarray: ((...args) => any)
        • (...args): any

        • Parameters

          • Rest ...args: any[]

          Returns any

    • join: ((...args) => any)
        • (...args): any

        • Parameters

          • Rest ...args: any[]

          Returns any

    • rsplit: ((...args) => any)
        • (...args): any

        • Parameters

          • Rest ...args: any[]

          Returns any

    • split: ((...args) => any)
        • (...args): any

        • Parameters

          • Rest ...args: any[]

          Returns any

    • splitlines: ((...args) => any)
        • (...args): any

        • Parameters

          • Rest ...args: any[]

          Returns any

    strings

    strings: {
        [name: string]: any;
    }

    Elementwise string functions (numpy.strings)

    Type declaration

    • [name: string]: any

    Testing

    testing

    testing: "/home/runner/work/ndarray-js/ndarray-js/src/modules/testing"

    Assertion helpers (numpy.testing).

    Transformations

    apply_along_axis

    apply_along_axis: ((a, ...rest) => NDArray) & ((...args) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ((lane, ...args) => any) | {
              func1d: ((lane, ...args) => any);
          } & {
              axis: number;
          } & {
              arr: ArrOrAny;
          } & {
              args: any[];
          }
        • Rest ...rest: [axis: number | {
              func1d: ((lane, ...args) => any);
          } & {
              axis: number;
          } & {
              arr: ArrOrAny;
          } & {
              args: any[];
          }, arr: ArrOrAny | {
              func1d: ((lane, ...args) => any);
          } & {
              axis: number;
          } & {
              arr: ArrOrAny;
          } & {
              args: any[];
          }, args: any[] | {
              func1d: ((lane, ...args) => any);
          } & {
              axis: number;
          } & {
              arr: ArrOrAny;
          } & {
              args: any[];
          }]

        Returns NDArray

    Type declaration

    concatenate

    concatenate: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: NDArray[] | {
              arrays: NDArray[];
          } & {
              axis: number;
          }
        • Rest ...rest: [axis: number | {
              arrays: NDArray[];
          } & {
              axis: number;
          }]

        Returns NDArray

    stack

    stack: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: NDArray[] | {
              arrays: NDArray[];
          } & {
              axis: number;
          }
        • Rest ...rest: [axis: number | {
              arrays: NDArray[];
          } & {
              axis: number;
          }]

        Returns NDArray

    transpose

    transpose: ((a, ...rest) => NDArray)

    Type declaration

      • (a, ...rest): NDArray

      • Parameters

        • a: ArrOrAny | {
              a: ArrOrAny;
          } & {
              axes: number[];
          }
        • Rest ...rest: [axes: number[] | {
              a: ArrOrAny;
          } & {
              axes: number[];
          }]

        Returns NDArray

    Types

    Complex

    Complex: typeof Complex

    Complex number class: new np.Complex(re, im)

    can_cast

    can_cast: ((...args) => any)

    Type declaration

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

    isdtype

    isdtype: ((...args) => any)

    Type declaration

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

    issubdtype

    issubdtype: ((...args) => any)

    Type declaration

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

    mintypecode

    mintypecode: ((...args) => any)

    Type declaration

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

    promote_types

    promote_types: ((...args) => any)

    Type declaration

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

    typename

    typename: ((...args) => any)

    Type declaration

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

    common_type

    complex

    dtype

    finfo

    iinfo

    iscomplexobj

    isrealobj

    isscalar

    • isscalar(obj): boolean

    • Parameters

      • obj: any

      Returns boolean

    min_scalar_type

    result_type

    Windows

    bartlett

    bartlett: ((...args) => any)

    Type declaration

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

    blackman

    blackman: ((...args) => any)

    Type declaration

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

    hamming

    hamming: ((...args) => any)

    Type declaration

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

    hanning

    hanning: ((...args) => any)

    Type declaration

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

    kaiser

    kaiser: ((...args) => any)

    Type declaration

      • (...args): any

      • Parameters

        • Rest ...args: any[]

        Returns any

    Settings

    Member Visibility

    Theme

    On This Page

    ndimshapesizeatleast_1datleast_2datleast_3dexpand_dimsmatrix_transposemoveaxispermute_dimsrollaxissqueezeswapaxesaddarctan2atan2bitwise_andbitwise_countbitwise_invertbitwise_left_shiftbitwise_orbitwise_right_shiftbitwise_shift_leftbitwise_shift_rightbitwise_xorcopysigndividedivide_intdivmodequalfloat_powerfloor_dividefmaxfminfmodgcdgreatergreater_equalheavisidehypotlcmldexpleft_shiftlessless_equallogaddexplogaddexp2logical_andlogical_orlogical_xormaximumminimummodmultiplynextafternot_equalpowpowerremainderright_shiftsubtracttrue_dividebroadcastbroadcast_arraysbroadcast_shapesbroadcast_toarrayasanyarrayasarrayastypecopycopytofromlistravelrequirereshapetolistallclosearray_equalarray_equivisclosearangeasarray_chkfiniteascontiguousarrayasfortranarrayasmatrixbmatdiagdiagflatemptyempty_likeeyefrom_dlpackfrombufferfromfunctionfromiterfullfull_likegeomspaceidentitylinspacelogspacematmeshgridmgridogridonesones_likerectritriltriuvanderzeroszeros_likecumprodcumsumcumulative_prodcumulative_sumnancumprodnancumsumdiffediff1dgradientabsacosacoshanglearoundasinasinhatanatanhbitwise_notcbrtceilclipconjconjugatecoscoshdeg2raddegreesexpexp2expm1fixfloorfrexpi0imaginvertiscomplexisfiniteisinfisnanisneginfisposinfisrealloglog10log1plog2logical_notmodfnan_to_numnegativepositiverad2degradiansrealreal_if_closereciprocalrintroundsignsignbitsinsincsinhspacingsqrtsquaretantanhtruncvalueOfexceptionsgeterrgeterrcallseterrseterrcallerrstatefftarray2stringarray_reprarray_strbase_reprbinary_reprformat_float_positionalformat_float_scientificget_printoptionspackbitsset_printoptionsunpackbitsprintoptionsapply_over_axesfrompyfuncpiecewisevectorizebincountdigitizehistogramhistogram2dhistogram_bin_edgeshistogramdddiag_indicesdiag_indices_fromindicesix_mask_indicesravel_multi_indextril_indicestril_indices_fromtriu_indicestriu_indices_fromunravel_indexc_index_expr_s_choosecompressdiagonalfill_diagonalplaceputput_along_axisputmaskselecttaketake_along_axisfromfilefromregexfromstringgenfromtxtlibloadloadtxtmemmapsavesavetxtsavezsavez_compressedappenddeleteinsertresizetrim_zerosflatiteriterablendenumeratenested_itersndindexnditerblockcolumn_stackconcatdstackhstackvstackdoteinsuminnerkronlinalgmatmulmatvecoutertensordottracevdotvecdotvecmateinsum_pathNDArraymodulesconvolvecrossemathinterptrapezoidunwrapeeuler_gammainfnannewaxispimay_share_memoryshares_memoryrandomDataSourceFalse_True_absoluteamaxaminarccosarccosharcsinarcsinharctanarctanhassignbusday_countbusday_offsetbusdaycalendardatetime_as_stringdatetime_datafabsis_busdayisnatlittle_endianndarrayisfortranpadpolypoly1dpolyaddpolyderpolydivpolyfitpolyintpolymulpolynomialpolysubpolyvalrootsallanyargmaxargmincount_nonzerolenmaxmeanminnanargmaxnanargminnanmaxnanmeannanminnanprodnanstdnansumnanvarnormprodproductptpstdsumvarflipfliplrflipudrollrot90repeattileargwhereextractflatnonzerononzerosearchsortedwheregroup_byintersect1disinsetdiff1dsetxor1dunion1duniqueunique_allunique_countsunique_inverseunique_valuesget_includegetbufsizeinfosetbufsizeshow_configshow_runtimeargpartitionargsortlexsortpartitionsortsort_complexarray_splitdsplithsplitsplitunstackvsplitaveragecorrcoefcorrelatecovmediannanmediannanpercentilenanquantilepercentilequantilecharstringstestingapply_along_axisconcatenatestacktransposeComplexcan_castisdtypeissubdtypemintypecodepromote_typestypenamecommon_typecomplexdtypefinfoiinfoiscomplexobjisrealobjisscalarmin_scalar_typeresult_typebartlettblackmanhamminghanningkaiser

    Generated using TypeDoc