Skip to main content

Documentation Index

Fetch the complete documentation index at: https://numpyts.dev/llms.txt

Use this file to discover all available pages before exploring further.

​
take

Take elements from an array along an axis. 
function take(a: ArrayLike, indices: number[], axis?: number): NDArray
NameTypeDefaultDescription
aArrayLike—Source array.
indicesArrayLike—Indices of the values to extract.
axisnumberundefinedAxis along which to select values. When undefined, the input array is flattened before indexing.
Returns: NDArray — Array of values taken from a at the specified indices. 
import * as np from 'numpy-ts';

const a = np.array([10, 20, 30, 40, 50]);
np.take(a, [0, 2, 4]);
// array([10, 30, 50])

const mat = np.array([[1, 2], [3, 4], [5, 6]]);
np.take(mat, [0, 2], 0);
// array([[1, 2],
//        [5, 6]])

​
put

Replace specified elements of an array with given values. 
function put(
  a: NDArray,
  indices: number[],
  values: ArrayLike
): void
NameTypeDefaultDescription
aNDArray—Target array. Modified in-place.
indicesnumber[]—Flat indices of elements to replace.
valuesArrayLike—Values to place at the target indices. If shorter than indices, values are repeated cyclically.
Returns: void — The array a is modified in-place. 
import * as np from 'numpy-ts';

const a = np.array([0, 0, 0, 0, 0]);
np.put(a, [1, 3], [10, 20]);
// a is now array([0, 10, 0, 20, 0])

​
choose

Construct an array from an index array and a list of arrays to choose from. 
function choose(a: ArrayLike, choices: ArrayLike[]): NDArray
NameTypeDefaultDescription
aArrayLike—Index array. Each value selects which array in choices to take the corresponding element from.
choicesArrayLike[]—List of arrays to choose from. All must be broadcastable to the same shape.
Returns: NDArray — Array formed by picking elements from choices according to a. 
import * as np from 'numpy-ts';

const choices = [
  np.array([0, 1, 2, 3]),
  np.array([10, 11, 12, 13]),
  np.array([20, 21, 22, 23]),
];
const idx = np.array([0, 2, 1, 0]);

np.choose(idx, choices);
// array([0, 21, 12, 3])

​
compress

Return selected slices of an array along a given axis. 
function compress(condition: ArrayLike, a: ArrayLike, axis?: number): NDArray
NameTypeDefaultDescription
conditionArrayLike—Boolean array selecting which entries to keep. Its length must match the size of a along the given axis.
aArrayLike—Array from which to extract.
axisnumberundefinedAxis along which to operate. When undefined, the array is flattened first.
Returns: NDArray — Array containing only the slices of a where condition is true. 
import * as np from 'numpy-ts';

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

np.compress([true, false, true], a, 0);
// array([[1, 2],
//        [5, 6]])

np.compress([true, false], a, 1);
// array([[1],
//        [3],
//        [5]])

​
select

Return an array drawn from elements in choicelist depending on conditions. 
function select(
  condlist: ArrayLike[],
  choicelist: ArrayLike[],
  defaultVal?: number
): NDArray
NameTypeDefaultDescription
condlistArrayLike[]—List of boolean arrays. The first condition that is true determines which choice is used.
choicelistArrayLike[]—List of arrays from which output elements are taken. Must be the same length as condlist.
defaultValnumber0Value used when no condition is satisfied.
Returns: NDArray — Array where element i is taken from choicelist[j][i] for the first j where condlist[j][i] is true, or default_ if no condition is true. 
import * as np from 'numpy-ts';

const x = np.arange(6);
const result = np.select(
  [np.less(x, 2), np.greater(x, 3)],
  [x, np.multiply(x, 10)],
  -1
);
// array([0, 1, -1, -1, 40, 50])

​
place

Change elements of an array based on a boolean mask and replacement values. 
function place(a: NDArray, mask: ArrayLike, vals: ArrayLike): void
NameTypeDefaultDescription
aNDArray—Array to modify in-place.
maskArrayLike—Boolean mask. Must be broadcastable to a.
valsArrayLike—Values to place into a where mask is true. Cycled if shorter than the number of true values.
Returns: void — The array arr is modified in-place. 
import * as np from 'numpy-ts';

const a = np.array([0, 1, 2, 3, 4]);
np.place(a, np.greater(a, 2), [10, 20]);
// a is now array([0, 1, 2, 10, 20])

​
putmask

Change elements of an array based on a boolean mask. 
function putmask(a: NDArray, mask: ArrayLike, values: ArrayLike): void
NameTypeDefaultDescription
aNDArray—Target array. Modified in-place.
maskArrayLike—Boolean mask. Where true, a is replaced by the corresponding element from values.
valuesArrayLike—Replacement values. Cycled if shorter than the number of true entries in mask.
Returns: void — The array a is modified in-place. 
import * as np from 'numpy-ts';

const a = np.array([1, 2, 3, 4, 5]);
np.putmask(a, np.array([true, false, true, false, true]), [10, 20, 30]);
// a is now array([10, 2, 20, 4, 30])

​
take_along_axis

Take values from an array by matching indices along an axis. 
function take_along_axis(arr: ArrayLike, indices: ArrayLike, axis: number): NDArray
NameTypeDefaultDescription
arrArrayLike—Source array.
indicesArrayLike—Indices to take along each slice of arr. Must have the same number of dimensions as arr.
axisnumber—The axis to take along.
Returns: NDArray — Array of values gathered from arr at the given indices along axis. 
import * as np from 'numpy-ts';

const a = np.array([[10, 30, 20], [60, 40, 50]]);
const idx = np.argsort(a, 1);

np.take_along_axis(a, idx, 1);
// array([[10, 20, 30],
//        [40, 50, 60]])

​
put_along_axis

Put values into an array by matching indices along an axis. 
function put_along_axis(
  arr: NDArray,
  indices: ArrayLike,
  values: ArrayLike,
  axis: number
): void
NameTypeDefaultDescription
arrNDArray—Destination array. Modified in-place.
indicesArrayLike—Indices along axis where values are placed.
valuesArrayLike—Values to insert. Must be broadcastable to indices.
axisnumber—The axis along which to put values.
Returns: void — The array arr is modified in-place. 
import * as np from 'numpy-ts';

const a = np.zeros([2, 3]);
const idx = np.array([[1], [2]]);
np.put_along_axis(a, idx, 99, 1);
// a is now array([[0, 99, 0],
//                 [0, 0, 99]])

​
copyto

Copy values from one array to another. 
function copyto(dst: NDArray, src: ArrayLike | number | bigint): void
NameTypeDefaultDescription
dstNDArray—Destination array. Modified in-place.
srcArrayLike | number | bigint—Source array or scalar. Must be broadcastable to dst.
Returns: void — The array dst is modified in-place. 
import * as np from 'numpy-ts';

const dst = np.zeros([3]);
np.copyto(dst, np.array([1, 2, 3]));
// dst is now array([1, 2, 3])

​
broadcast_to

Broadcast an array to a new shape without copying data. 
function broadcast_to(a: ArrayLike, shape: number[]): NDArray
NameTypeDefaultDescription
aArrayLike—The array to broadcast.
shapenumber[]—Target shape. Must be compatible with the input shape under NumPy broadcasting rules.
Returns: NDArray — A read-only view of the original array with the given shape. 
import * as np from 'numpy-ts';

const a = np.array([1, 2, 3]);
const b = np.broadcast_to(a, [3, 3]);
// array([[1, 2, 3],
//        [1, 2, 3],
//        [1, 2, 3]])

​
broadcast_arrays

Broadcast any number of arrays against each other. 
function broadcast_arrays(...arrays: ArrayLike[]): NDArray[]
NameTypeDefaultDescription
...arraysArrayLike[]—Arrays to broadcast.
Returns: NDArray[] — List of arrays with the same shape, broadcast from the inputs. 
import * as np from 'numpy-ts';

const a = np.array([[1], [2], [3]]);   // shape [3, 1]
const b = np.array([10, 20]);          // shape [2]

const [ba, bb] = np.broadcast_arrays(a, b);
// ba: array([[1, 1], [2, 2], [3, 3]])      -- shape [3, 2]
// bb: array([[10, 20], [10, 20], [10, 20]]) -- shape [3, 2]

​
broadcast_shapes

Compute the shape resulting from broadcasting the given shapes together. 
function broadcast_shapes(...shapes: number[][]): number[]
NameTypeDefaultDescription
...shapesnumber[][]—Array shapes to broadcast together.
Returns: number[] — The broadcast shape. Throws: Error if the shapes are not compatible for broadcasting. 
import * as np from 'numpy-ts';

np.broadcast_shapes([3, 1], [1, 4]);
// [3, 4]

np.broadcast_shapes([5], [3, 5], [1, 3, 5]);
// [1, 3, 5]