Function np

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

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

    Parameters

    Returns any

Binary operators

add bitwise_and bitwise_or bitwise_shift_left bitwise_shift_right bitwise_xor divide divide_int equal greater greater_equal less less_equal logical_and logical_or maximum minimum mod multiply not_equal pow subtract

Casting and reshaping

array asarray fromlist ravel reshape tolist

Constructors

arange empty geomspace linspace ones zeros

Elementwise operators

abs acos acosh asin asinh atan atanh bitwise_not ceil cos cosh exp floor isfinite isnan log log10 log1p log2 logical_not negative round sign sin sinh sqrt square tan tanh

Main

NDArray modules

Math constants

e pi

Modules

random

Other

allclose assign atan2 isclose nanquantile nonzero quantile take where

Reducers

all any argmax argmin max mean min norm prod product std sum var

Transformations

apply_along_axis concatenate sort stack transpose

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

equal

equal: Wrapper

greater

greater: Wrapper

greater_equal

greater_equal: Wrapper

less

less: Wrapper

less_equal

less_equal: Wrapper

logical_and

logical_and: Wrapper

logical_or

logical_or: Wrapper

maximum

maximum: Wrapper

minimum

minimum: Wrapper

mod

mod: Wrapper

multiply

multiply: Wrapper

not_equal

not_equal: Wrapper

pow

pow: Wrapper

subtract

subtract: Wrapper

Casting and reshaping

array

array: ((A) => NDArray<any>)

Type declaration

asarray

asarray: (<T>(A) => NDArray<T>)

Type declaration

fromlist

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

Type declaration

ravel

ravel: ((A) => NDArray<TypedArrayConstructor>)

Type declaration

reshape

reshape: ((A, shape_or_first, ...more_shape) => NDArray<TypedArrayConstructor>)

Type declaration

tolist

Constructors

arange

arange: ((arg0, arg1?) => NDArray<TypedArrayConstructor>)

Type declaration

empty

empty: ((shape, dtype?) => NDArray<TypedArrayConstructor>)

Type declaration

geomspace

geomspace: ((start, stop, steps?, endpoint?) => NDArray<Float64ArrayConstructor> | NDArray<TypedArrayConstructor>)

Type declaration

linspace

linspace: ((start, stop, steps?, endpoint?) => NDArray<Float64ArrayConstructor>)

Type declaration

    • (start, stop, steps?, endpoint?): NDArray<Float64ArrayConstructor>

    • Parameters

      • start: number
      • stop: number
      • steps: number = 50
      • endpoint: boolean = true

      Returns NDArray<Float64ArrayConstructor>

ones

ones: ((shape, dtype?) => NDArray<TypedArrayConstructor>)

Type declaration

zeros

zeros: ((shape, dtype?) => NDArray<TypedArrayConstructor>)

Type declaration

Elementwise operators

abs

abs: Wrapper

acos

acos: Wrapper

acosh

acosh: Wrapper

asin

asin: Wrapper

asinh

asinh: Wrapper

atan

atan: Wrapper

atanh

atanh: Wrapper

bitwise_not

bitwise_not: Wrapper

ceil

ceil: Wrapper

cos

cos: Wrapper

cosh

cosh: Wrapper

exp

exp: Wrapper

floor

floor: Wrapper

isfinite

isfinite: Wrapper

isnan

isnan: Wrapper

log

log: Wrapper

log10

log10: Wrapper

log1p

log1p: Wrapper

log2

log2: Wrapper

logical_not

logical_not: Wrapper

negative

negative: Wrapper

round

round: Wrapper

sign

sign: Wrapper

sin

sin: Wrapper

sinh

sinh: Wrapper

sqrt

sqrt: Wrapper

square

square: Wrapper

tan

tan: Wrapper

tanh

tanh: Wrapper

Main

NDArray

NDArray: typeof NDArray

Namespace modules

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

Type declaration

    Math constants

    e

    e: number

    pi

    pi: number

    Modules

    random

    random: "/mnt/data/documents/projects/ndarray-js/src/modules/random"

    Other

    allclose

    allclose: ((A, B, rtol?, atol?, equal_nan?) => boolean)

    Type declaration

      • (A, B, rtol?, atol?, equal_nan?): boolean

      • Parameters

        • A: any
        • B: any
        • rtol: number = 1.e-5
        • atol: number = 1.e-8
        • equal_nan: boolean = false

        Returns boolean

    assign

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

    Type declaration

    atan2

    atan2: Wrapper

    isclose

    isclose: ((A, B, rtol?, atol?, equal_nan?) => NDArray<Uint8ArrayConstructor>)

    Type declaration

      • (A, B, rtol?, atol?, equal_nan?): NDArray<Uint8ArrayConstructor>

      • Parameters

        • A: any
        • B: any
        • rtol: number = 1.e-5
        • atol: number = 1.e-8
        • equal_nan: boolean = false

        Returns NDArray<Uint8ArrayConstructor>

    nanquantile

    nanquantile: Wrapper

    nonzero

    nonzero: ((a) => NDArray<Int32ArrayConstructor>[])

    Type declaration

    quantile

    quantile: Wrapper

    take

    take: ((a, indices, axis) => NDArray<Float64ArrayConstructor>)

    Type declaration

      • (a, indices, axis): NDArray<Float64ArrayConstructor>

      • Parameters

        • a: NDArray<Float64ArrayConstructor>
        • indices: NDArray<Float64ArrayConstructor>
        • axis: number

        Returns NDArray<Float64ArrayConstructor>

    where

    where: ((condition, x, y, out?) => NDArray<Float64ArrayConstructor>)

    Type declaration

      • (condition, x, y, out?): NDArray<Float64ArrayConstructor>

      • Parameters

        • condition: NDArray<Float64ArrayConstructor>
        • x: NDArray<Float64ArrayConstructor>
        • y: NDArray<Float64ArrayConstructor>
        • out: NDArray<Float64ArrayConstructor> = null

        Returns NDArray<Float64ArrayConstructor>

    Reducers

    all

    all: Wrapper<Uint8ArrayConstructor>

    any

    any: Wrapper<Uint8ArrayConstructor>

    argmax

    argmax: Wrapper<Int32ArrayConstructor>

    argmin

    argmin: Wrapper<Int32ArrayConstructor>

    max

    max: Wrapper<Float64ArrayConstructor>

    mean

    mean: Wrapper<Float64ArrayConstructor>

    min

    min: Wrapper<Float64ArrayConstructor>

    norm

    norm: Wrapper

    prod

    prod: Wrapper<Float64ArrayConstructor>

    product

    product: Wrapper<Float64ArrayConstructor>

    std

    std: Wrapper

    sum

    sum: Wrapper<Float64ArrayConstructor>

    var

    var: Wrapper

    Transformations

    apply_along_axis

    apply_along_axis: ((arr, axis, transform, dtype?) => ArrayOrConstant)

    Type declaration

    concatenate

    concatenate: ((arrays, axis?) => NDArray<TypedArrayConstructor>)

    Type declaration

    sort

    sort: Wrapper

    stack

    stack: ((arrays, axis?) => NDArray<TypedArrayConstructor>)

    Type declaration

    transpose

    transpose: ((arr, axes?) => NDArray<TypedArrayConstructor>)

    Type declaration

    Settings

    Member Visibility

    Theme

    On This Page

    addbitwise_andbitwise_orbitwise_shift_leftbitwise_shift_rightbitwise_xordividedivide_intequalgreatergreater_equallessless_equallogical_andlogical_ormaximumminimummodmultiplynot_equalpowsubtractarrayasarrayfromlistravelreshapetolistarangeemptygeomspacelinspaceoneszerosabsacosacoshasinasinhatanatanhbitwise_notceilcoscoshexpfloorisfiniteisnanloglog10log1plog2logical_notnegativeroundsignsinsinhsqrtsquaretantanhNDArraymodulesepirandomallcloseassignatan2isclosenanquantilenonzeroquantiletakewhereallanyargmaxargminmaxmeanminnormprodproductstdsumvarapply_along_axisconcatenatesortstacktranspose

    Generated using TypeDoc