Type Testing

isnan

Test element-wise for NaN.

function isnan(x: ArrayLike): NDArray

Name	Type	Default	Description
`x`	`ArrayLike`	—	Input array.

Returns: NDArray — Boolean array, true where x is NaN.

import * as np from 'numpy-ts';

const result = np.isnan([1, NaN, Infinity, 0]);
// array([false, true, false, false])

isinf

Test element-wise for positive or negative infinity.

function isinf(x: ArrayLike): NDArray

Name	Type	Default	Description
`x`	`ArrayLike`	—	Input array.

Returns: NDArray — Boolean array, true where x is +Inf or -Inf.

import * as np from 'numpy-ts';

const result = np.isinf([1, Infinity, -Infinity, NaN]);
// array([false, true, true, false])

isfinite

Test element-wise for finiteness (not infinity and not NaN).

function isfinite(x: ArrayLike): NDArray

Name	Type	Default	Description
`x`	`ArrayLike`	—	Input array.

Returns: NDArray — Boolean array, true where x is finite.

import * as np from 'numpy-ts';

const result = np.isfinite([1, 0, Infinity, NaN, -Infinity]);
// array([true, true, false, false, false])

isneginf

Test element-wise for negative infinity.

function isneginf(x: ArrayLike): NDArray

Name	Type	Default	Description
`x`	`ArrayLike`	—	Input array.

Returns: NDArray — Boolean array, true where x is -Infinity.

import * as np from 'numpy-ts';

const result = np.isneginf([1, -Infinity, Infinity, NaN]);
// array([false, true, false, false])

isposinf

Test element-wise for positive infinity.

function isposinf(x: ArrayLike): NDArray

Name	Type	Default	Description
`x`	`ArrayLike`	—	Input array.

Returns: NDArray — Boolean array, true where x is +Infinity.

import * as np from 'numpy-ts';

const result = np.isposinf([1, -Infinity, Infinity, NaN]);
// array([false, false, true, false])

iscomplex

Test element-wise whether values are complex (have non-zero imaginary part).

function iscomplex(x: ArrayLike): NDArray

Name	Type	Default	Description
`x`	`ArrayLike`	—	Input array.

Returns: NDArray — Boolean array, true where the element has a non-zero imaginary part.

import * as np from 'numpy-ts';

const a = np.array([1, 2, 3], 'complex128');
const result = np.iscomplex(a);
// array([false, false, false])  -- real values stored as complex

iscomplexobj

Return true if the input is a complex-typed array or has complex dtype.

function iscomplexobj(x: ArrayLike): boolean

Name	Type	Default	Description
`x`	`ArrayLike`	—	Input to check.

Returns: boolean — true if x is an array with complex dtype (complex64 or complex128).

import * as np from 'numpy-ts';

np.iscomplexobj(np.array([1, 2], 'complex128'));
// true

np.iscomplexobj(np.array([1, 2], 'float64'));
// false

isreal

Test element-wise whether values are real (have zero imaginary part).

function isreal(x: ArrayLike): NDArray

Name	Type	Default	Description
`x`	`ArrayLike`	—	Input array.

Returns: NDArray — Boolean array, true where the element has zero imaginary part.

import * as np from 'numpy-ts';

const a = np.array([1, 2, 3]);
const result = np.isreal(a);
// array([true, true, true])

isrealobj

Return true if the input is not a complex-typed array.

function isrealobj(x: ArrayLike): boolean

Name	Type	Default	Description
`x`	`ArrayLike`	—	Input to check.

Returns: boolean — true if x is not a complex array (i.e., dtype is not complex64 or complex128).

import * as np from 'numpy-ts';

np.isrealobj(np.array([1, 2, 3]));
// true

np.isrealobj(np.array([1, 2], 'complex128'));
// false

isscalar

Return true if the input is a scalar value (number, boolean, bigint, or string).

function isscalar(val: ArrayLike): boolean

Name	Type	Default	Description
`val`	`ArrayLike`	—	Value to test.

Returns: boolean — true if element is a scalar type.

import * as np from 'numpy-ts';

np.isscalar(3.14);      // true
np.isscalar(true);       // true
np.isscalar('hello');    // true
np.isscalar([1, 2, 3]); // false
np.isscalar(np.array([1])); // false

isnat

Test element-wise for Not-a-Time. Since numpy-ts does not implement datetime dtypes, this always returns false for every element. Included for API compatibility with NumPy.

function isnat(x: ArrayLike): NDArray

Name	Type	Default	Description
`x`	`ArrayLike`	—	Input array.

Returns: NDArray — Boolean array of all false values (datetime dtypes are not supported).

import * as np from 'numpy-ts';

const result = np.isnat([1, 2, NaN]);
// array([false, false, false])

isfortran

Return true if the array is Fortran-contiguous and not C-contiguous.

function isfortran(x: ArrayLike): boolean

Name	Type	Default	Description
`x`	`ArrayLike`	—	Input array.

Returns: boolean — true if the array is Fortran-contiguous (column-major) and not C-contiguous. In numpy-ts, arrays are always C-contiguous, so this typically returns false.

import * as np from 'numpy-ts';

const a = np.array([[1, 2], [3, 4]]);
np.isfortran(a);
// false (numpy-ts arrays are C-contiguous)

iterable

Return true if the input can be iterated over.

function iterable(obj: ArrayLike): boolean

Name	Type	Default	Description
`obj`	`ArrayLike`	—	Value to test.

Returns: boolean — true if y is iterable (arrays, NDArrays, strings, etc.).

import * as np from 'numpy-ts';

np.iterable([1, 2, 3]);          // true
np.iterable(np.array([1, 2]));   // true
np.iterable(42);                  // false

isdtype

Test whether a dtype belongs to a specified kind or set of dtypes.

function isdtype(dtype: DType, kind: string): boolean

Name	Type	Default	Description
`dtype`	`DType`	—	The dtype to test.
`kind`	`string`	—	A dtype kind string (e.g., `'integral'`, `'real floating'`, `'numeric'`).

Returns: boolean — true if dtype matches the specified kind.

import * as np from 'numpy-ts';

np.isdtype('float64', 'real floating');
// true

np.isdtype('int32', 'integral');
// true

np.isdtype('float32', ['float32', 'float64']);
// true

np.isdtype('int32', 'real floating');
// false

real_if_close

If the imaginary part of an array is close to zero, return only the real part. Otherwise, return the input unchanged.

function real_if_close(x: ArrayLike, tol?: number): NDArray

Name	Type	Default	Description
`x`	`ArrayLike`	—	Input array.
`tol`	`number`	`100`	Tolerance factor. The imaginary part is considered close to zero if `max(abs(imag)) < tol * eps` where `eps` is the machine epsilon for the dtype.

Returns: NDArray — Real-valued array if the imaginary part is negligible, otherwise the original array.

Changed in v1.7.0: input that is already real is handed straight back as a view rather than a copy; the complex branches still allocate. This matches NumPy. Writes to the result reach the input array, so call .copy() if you need an independent buffer. base is set on exactly the results that alias.

import * as np from 'numpy-ts';

// Imaginary part is negligibly small
const a = np.array([1 + 1e-15, 2 + 0, 3 - 1e-15], 'complex128');
const result = np.real_if_close(a);
// array([1, 2, 3])  -- returned as real float64

Overview

NDArray

Array Creation

Math

Array Manipulation

Reductions & Statistics

Linear Algebra

Logic & Comparison

Sorting & Searching

Set Operations

Bitwise

Indexing

Gradient & Differences

Polynomials

Random (np.random)

FFT (np.fft)

I/O

Utilities

isnan

isinf

isfinite

isneginf

isposinf

iscomplex

iscomplexobj

isreal

isrealobj

isscalar

isnat

isfortran

iterable

isdtype

real_if_close

​isnan

​isinf

​isfinite

​isneginf

​isposinf

​iscomplex

​iscomplexobj

​isreal

​isrealobj

​isscalar

​isnat

​isfortran

​iterable

​isdtype

​real_if_close

isnan

isinf

isfinite

isneginf

isposinf

iscomplex

iscomplexobj

isreal

isrealobj

isscalar

isnat

isfortran

iterable

isdtype

real_if_close