Class NDArray

Multi dimensional array.

Implements

HasDType

Index

Transformations Transpose.

Unary logical operators

logical_not

Unary operators

abs bitwise_not negative round

Attributes

conjugate

conjugate: MethodWrapper<((a) => NDArray), {
a: ArrOrAny;
}>

Complex conjugate

Type declaration

- (a): NDArray
- Parameters
  - a: NDArray
  Returns NDArray

Type declaration

a: ArrOrAny

`Readonly` itemsize

itemsize: number

Bytes per element

`Readonly` mT

mT: NDArray

Transpose of the last two axes

`Readonly` nbytes

nbytes: number

Total bytes consumed by the elements

`Readonly` ndim

ndim: number

Number of dimensions

`Readonly` shape

shape: number[]

`Readonly` strides

strides: number[]

Strides in bytes of a C-contiguous array

dtype

get dtype(): DType
Returns DType
Implementation of HasDType.dtype
- Defined in src/NDArray.ts:36

flat

get flat(): Buffer
Returns Buffer
- Defined in src/NDArray.ts:283

imag

get imag(): NDArray
Imaginary part (zeros for real arrays)

Returns NDArray
- Defined in src/NDArray.ts:273

length

get length(): number
Returns number
- Defined in src/NDArray.ts:321

real

get real(): NDArray
Real part (the array itself for real arrays)

Returns NDArray
- Defined in src/NDArray.ts:271

size

get size(): number
Returns number
- Defined in src/NDArray.ts:279

Binary logical operators

logical_and

logical_and: Wrapper

logical_or

logical_or: Wrapper

logical_xor

logical_xor: Wrapper

Binary operators

add

add: Wrapper

bitwise_and

bitwise_and: Wrapper

bitwise_or

bitwise_or: Wrapper

bitwise_shift_left

bitwise_shift_left: Wrapper

bitwise_shift_right

bitwise_shift_right: Wrapper

bitwise_xor

bitwise_xor: Wrapper

divide

divide: Wrapper

divide_int

divide_int: Wrapper

maximum

maximum: Wrapper

minimum

minimum: Wrapper

mod

mod: Wrapper

multiply

multiply: Wrapper

pow

pow: Wrapper

subtract

subtract: Wrapper

Casting

astype

astype: MethodWrapper<((x, dtype, copy) => NDArray), {
    x: ArrOrAny;
} & {
    dtype: DType;
} & {
    copy: boolean;
}>

Type declaration

- (x, dtype, copy): NDArray
- Parameters
  - x: NDArray
  - dtype: DType
  - copy: boolean
  Returns NDArray

byteswap

byteswap: ((inplace?) => NDArray)

Swaps the bytes of every element

Type declaration

- (inplace?): NDArray
- Parameters
  - Optional inplace: boolean
  Returns NDArray

to_device

to_device: ((device) => NDArray)

Does nothing (arrays always live on the "cpu")

Type declaration

- (device): NDArray
- Parameters
  - device: string
  Returns NDArray

tobytes

tobytes: (() => Uint8Array)

Bytes of the array (little endian, C order)

Type declaration

- (): Uint8Array
- Returns Uint8Array

tofile

tofile: ((fid, sep?, format?) => void)

Writes the array to a file (binary, or text with sep)

Type declaration

- (fid, sep?, format?): void
- Parameters
  - fid: any
  - Optional sep: string
  - Optional format: string
  Returns void

tolist

tolist: (() => any)

Type declaration

- (): any
- Returns any

view

view: ((dtype?) => NDArray)

A new view of the same data, optionally with another dtype (bytes are reinterpreted, copy for dtype changes)

Type declaration

- (dtype?): NDArray
- Parameters
  - Optional dtype: DType
  Returns NDArray

item

item(): any
Returns any
- Defined in src/NDArray.ts:328

Comparison operators

allclose

allclose: MethodWrapper<((a, b, rtol?, atol?, equal_nan?) => boolean), {
    a: ArrayOrConstant;
} & {
    b: ArrayOrConstant;
} & {
    rtol: number;
} & {
    atol: number;
} & {
    equal_nan: boolean;
}>

Type declaration

- (a, b, rtol?, atol?, equal_nan?): boolean
- Parameters
  - a: ArrayOrConstant
  - b: ArrayOrConstant
  - rtol: number = 1.e-5
  - atol: number = 1.e-8
  - equal_nan: boolean = false
  Returns boolean

equal

equal: Wrapper

greater

greater: Wrapper

greater_equal

greater_equal: Wrapper

isclose

isclose: MethodWrapper<((a, b, rtol?, atol?, equal_nan?) => NDArray), {
    a: ArrayOrConstant;
} & {
    b: ArrayOrConstant;
} & {
    rtol: number;
} & {
    atol: number;
} & {
    equal_nan: boolean;
}>

Type declaration

- (a, b, rtol?, atol?, equal_nan?): NDArray
- Parameters
  - a: ArrayOrConstant
  - b: ArrayOrConstant
  - rtol: number = 1.e-5
  - atol: number = 1.e-8
  - equal_nan: boolean = false
  Returns NDArray

less

less: Wrapper

less_equal

less_equal: Wrapper

not_equal

not_equal: Wrapper

Cumulative

cumprod

cumprod: MethodWrapper<((a, axis, dtype, out) => NDArray), {
    a: ArrOrAny;
} & {
    axis: number;
} & {
    dtype: DType;
} & {
    out: ArrOrAny;
}>

Type declaration

- (a, axis, dtype, out): NDArray
- Parameters
  - a: NDArray
  - axis: number
  - dtype: DType
  - out: NDArray
  Returns NDArray

cumsum

cumsum: MethodWrapper<((a, axis, dtype, out) => NDArray), {
    a: ArrOrAny;
} & {
    axis: number;
} & {
    dtype: DType;
} & {
    out: ArrOrAny;
}>

Type declaration

- (a, axis, dtype, out): NDArray
- Parameters
  - a: NDArray
  - axis: number
  - dtype: DType
  - out: NDArray
  Returns NDArray

Elementwise operators

clip

clip: Wrapper

conj

conj: Wrapper

Indexing

choose

choose: MethodWrapper<((a, choices, out, mode) => NDArray), {
    a: ArrOrAny;
} & {
    choices: NDArray | NDArray[];
} & {
    out: ArrOrAny;
} & {
    mode: IndexMode;
}>

Type declaration

- (a, choices, out, mode): NDArray
- Parameters
  - a: NDArray
  - choices: NDArray | NDArray[]
  - out: NDArray
  - mode: IndexMode
  Returns NDArray

compress

compress: MethodWrapper<((condition, a, axis, out) => NDArray), {
    condition: ArrOrAny;
} & {
    a: ArrOrAny;
} & {
    axis: number;
} & {
    out: ArrOrAny;
}>

Type declaration

- (condition, a, axis, out): NDArray
- Parameters
  - condition: NDArray
  - a: NDArray
  - axis: number
  - out: NDArray
  Returns NDArray

put

put: MethodWrapper<((a, ind, v, mode) => void), {
    a: ArrOrAny;
} & {
    ind: ArrOrAny;
} & {
    v: ArrOrAny;
} & {
    mode: IndexMode;
}>

Type declaration

- (a, ind, v, mode): void
- Parameters
  - a: NDArray
  - ind: NDArray
  - v: NDArray
  - mode: IndexMode
  Returns void

take

take: MethodWrapper<((a, indices, axis, out, mode) => NDArray), {
    a: ArrOrAny;
} & {
    indices: ArrOrAny;
} & {
    axis: number;
} & {
    out: ArrOrAny;
} & {
    mode: IndexMode;
}>

Type declaration

- (a, indices, axis, out, mode): NDArray
- Parameters
  - a: NDArray
  - indices: NDArray
  - axis: number
  - out: NDArray
  - mode: IndexMode
  Returns NDArray

Indexing / slicing

index

index: ((...where) => NDArray)

Type declaration

- (...where): NDArray
- Parameters
  - Rest ...where: GeneralIndexSpec[]
  Returns NDArray

Linear algebra

dot

dot: MethodWrapper<((a, b, out?) => NDArray), {
    a: ArrOrAny;
} & {
    b: ArrOrAny;
} & {
    out: ArrOrAny;
}>

Type declaration

- (a, b, out?): NDArray
- Parameters
  - a: NDArray
  - b: NDArray
  - out: NDArray = null
  Returns NDArray

trace

trace: MethodWrapper<((a, offset, axis1, axis2, dtype, out) => NDArray), {
    a: ArrOrAny;
} & {
    offset: number;
} & {
    axis1: number;
} & {
    axis2: number;
} & {
    dtype: DType;
} & {
    out: ArrOrAny;
}>

Type declaration

- (a, offset, axis1, axis2, dtype, out): NDArray
- Parameters
  - a: NDArray
  - offset: number
  - axis1: number
  - axis2: number
  - dtype: DType
  - out: NDArray
  Returns NDArray

Operators with assignment

add_assign

add_assign: Wrapper

assign

assign: Wrapper

bitwise_and_assign

bitwise_and_assign: Wrapper

bitwise_or_assign

bitwise_or_assign: Wrapper

bitwise_shift_left_assign

bitwise_shift_left_assign: Wrapper

bitwise_shift_right_assign

bitwise_shift_right_assign: Wrapper

divide_assign

divide_assign: Wrapper

divide_int_assign

divide_int_assign: Wrapper

logical_and_assign

logical_and_assign: Wrapper

logical_or_assign

logical_or_assign: Wrapper

maximum_assign

maximum_assign: Wrapper

minimum_assign

minimum_assign: Wrapper

mod_assign

mod_assign: Wrapper

multiply_assign

multiply_assign: Wrapper

pow_assign

pow_assign: Wrapper

subtract_assign

subtract_assign: Wrapper

Other

constructor

new NDArray(flat, shape?, dtype?): NDArray
Parameters
- flat: Buffer
- Optional shape: number[]
- Optional dtype: DType
Returns NDArray
- Defined in src/NDArray.ts:260

`Readonly` base

base: NDArray

`Readonly` device

device: string

`Readonly` flags

flags: {
    aligned: boolean;
    c_contiguous: boolean;
    f_contiguous: boolean;
    owndata: boolean;
    writeable: boolean;
}

Type declaration

aligned: boolean
c_contiguous: boolean
f_contiguous: boolean
owndata: boolean
writeable: boolean

fromlist

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

Type declaration

- (A, dtype?): NDArray
- Parameters
  - A: any
  - Optional dtype: DType
  Returns NDArray

op

op: GenericOperatorFunction

Generic operator function. See GenericOperatorFunction for details.

setflags

setflags: ((...args) => void)

Type declaration

- (...args): void
- Parameters
  - Rest ...args: any[]
  Returns void

[iterator]

[iterator](): Generator<NDArray, void, unknown>
Iterator over the first axis. For 1D arrays, yields numbers. For multidimensional arrays, yields array views.

Returns Generator<NDArray, void, unknown>
- Defined in src/NDArray.ts:316

item_if_scalar

item_if_scalar(): any
Returns a plain JS value for 0-d arrays, and the array itself otherwise

Returns any
- Defined in src/NDArray.ts:333

Reducers

all

all: Wrapper

any

any: Wrapper

argmax

argmax: Wrapper

argmin

argmin: Wrapper

max

max: Wrapper

mean

mean: Wrapper

min

min: Wrapper

norm

norm: Wrapper

prod

prod: Wrapper

product

product: Wrapper

ptp

ptp: Wrapper

std

std: Wrapper

sum

sum: Wrapper

var

var: Wrapper

Searching

nonzero

nonzero: MethodWrapper<((a) => NDArray), {
a: ArrOrAny;
}>

Type declaration

- (a): NDArray
- Parameters
  - a: NDArray
  Returns NDArray

Type declaration

a: ArrOrAny

searchsorted

searchsorted: MethodWrapper<((a, v, side, sorter) => NDArray), {
    a: ArrOrAny;
} & {
    v: ArrOrAny;
} & {
    side: "left" | "right";
} & {
    sorter: ArrOrAny;
}>

Type declaration

- (a, v, side, sorter): NDArray
- Parameters
  - a: NDArray
  - v: NDArray
  - side: "left" | "right"
  - sorter: NDArray
  Returns NDArray

Sorting

argpartition

argpartition: MethodWrapper<((a, kth, axis) => NDArray), {
    a: ArrOrAny;
} & {
    kth: number | number[];
} & {
    axis: number;
}>

Type declaration

- (a, kth, axis): NDArray
- Parameters
  - a: NDArray
  - kth: number | number[]
  - axis: number
  Returns NDArray

argsort

argsort: ((axis?) => NDArray)

Type declaration

- (axis?): NDArray
- Parameters
  - Optional axis: number | {
    axis?: number;
    }
  Returns NDArray

partition

partition: ((kth, axis?) => void)

Partially sorts the array in place (it is a full sort)

Type declaration

- (kth, axis?): void
- Parameters
  - kth: number | number[]
  - Optional axis: number
  Returns void

Transformations

copy

copy: (() => NDArray)

Type declaration

- (): NDArray
- Returns NDArray

diagonal

diagonal: MethodWrapper<((a, offset, axis1, axis2) => NDArray), {
    a: ArrOrAny;
} & {
    offset: number;
} & {
    axis1: number;
} & {
    axis2: number;
}>

Type declaration

- (a, offset, axis1, axis2): NDArray
- Parameters
  - a: NDArray
  - offset: number
  - axis1: number
  - axis2: number
  Returns NDArray

flatten

flatten: (() => NDArray)

Type declaration

- (): NDArray
- Returns NDArray

ravel

ravel: (() => NDArray)

Type declaration

- (): NDArray
- Returns NDArray

repeat

repeat: MethodWrapper<((a, repeats, axis) => NDArray), {
    a: ArrOrAny;
} & {
    repeats: number | number[] | NDArray;
} & {
    axis: number;
}>

Type declaration

- (a, repeats, axis): NDArray
- Parameters
  - a: NDArray
  - repeats: number | number[] | NDArray
  - axis: number
  Returns NDArray

reshape

reshape: ((shape, ...more_shape) => NDArray)

Type declaration

- (shape, ...more_shape): NDArray
- Parameters
  - shape: any
  - Rest ...more_shape: any[]
  Returns NDArray

resize

resize: ((...shape) => void)

Changes the shape in place, repeating or dropping data as needed

Type declaration

- (...shape): void
- Parameters
  - Rest ...shape: any[]
  Returns void

sort

sort: ((axis?) => NDArray)

Type declaration

- (axis?): NDArray
- Parameters
  - Optional axis: number | {
    axis?: number;
    }
  Returns NDArray

squeeze

squeeze: MethodWrapper<((a, axis) => NDArray), {
a: ArrOrAny;
} & {
axis: number | number[];
}>

Type declaration

- (a, axis): NDArray
- Parameters
  - a: NDArray
  - axis: number | number[]
  Returns NDArray

swapaxes

swapaxes: MethodWrapper<((arr, axisA, axisB) => NDArray), {
    a: ArrOrAny;
} & {
    axis1: number;
} & {
    axis2: number;
}>

Type declaration

- (arr, axisA, axisB): NDArray
- Parameters
  - arr: NDArray
  - axisA: number
  - axisB: number
  Returns NDArray

transpose

transpose: ((...axes) => NDArray)

Type declaration

- (...axes): NDArray
- Parameters
  - Rest ...axes: any[]
  Returns NDArray

Transformations Transpose.

T

get T(): NDArray
Returns NDArray
- Defined in src/NDArray.ts:308

Unary logical operators

logical_not

logical_not: Wrapper

Unary operators

abs

abs: Wrapper

bitwise_not

bitwise_not: Wrapper

negative

negative: Wrapper

round

round: Wrapper

Class NDArray

Implements

Index

Attributes

Binary logical operators

Binary operators

Casting

Comparison operators

Cumulative

Elementwise operators

Indexing

Indexing / slicing

Linear algebra

Operators with assignment

Other

Reducers

Searching

Sorting

Transformations

Transformations Transpose.

Unary logical operators

Unary operators

Attributes

conjugate

Type declaration

Parameters

Returns NDArray

Type declaration

a: ArrOrAny

Readonly itemsize

Readonly mT

Readonly nbytes

Readonly ndim

Readonly shape

Readonly strides

dtype

Returns DType

flat

Returns Buffer

imag

Returns NDArray

length

Returns number

real

Returns NDArray

size

Returns number

Binary logical operators

logical_and

logical_or

logical_xor

Binary operators

add

bitwise_and

bitwise_or

bitwise_shift_left

bitwise_shift_right

bitwise_xor

divide

divide_int

maximum

minimum

mod

multiply

pow

subtract

Casting

astype

Type declaration

Parameters

Returns NDArray

byteswap

Type declaration

Parameters

Returns NDArray

to_device

Type declaration

Parameters

Returns NDArray

tobytes

`Readonly` itemsize

`Readonly` mT

`Readonly` nbytes

`Readonly` ndim

`Readonly` shape

`Readonly` strides