Slicing & Indexing

Python vs TypeScript syntax

Because TypeScript does not support Python’s arr[0:5, :] subscript syntax, numpy-ts uses string-based slicing via the .slice() method. Every slice dimension is a string argument.

a[0:5]
a[0:5, :]
a[::-1]
a[::2, 1:3]
a[2]            # integer index, reduces dimension

a.slice('0:5')
a.slice('0:5', ':')
a.slice('::-1')
a.slice('::2', '1:3')
a.slice('2')            // integer index, reduces dimension

String slice syntax

The slice syntax mirrors Python’s start:stop:step:

Slice String	Meaning	Python equivalent
`':'`	All elements	`[:]`
`'0:5'`	Elements 0 through 4	`[0:5]`
`'2:'`	From index 2 to the end	`[2:]`
`':3'`	First 3 elements	`[:3]`
`'-3:'`	Last 3 elements	`[-3:]`
`'::2'`	Every other element	`[::2]`
`'::-1'`	Reversed	`[::-1]`
`'1:7:2'`	From 1 to 6, step 2	`[1:7:2]`
`'3'`	Single index (reduces dimension)	`[3]`

Basic slicing

All slicing returns a view — no data is copied. Modifications to the slice affect the original array.

import * as np from 'numpy-ts';

const a = np.arange(0, 10);  // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

// First 5 elements
a.slice('0:5').toArray();     // [0, 1, 2, 3, 4]

// Last 3 elements
a.slice('-3:').toArray();     // [7, 8, 9]

// Every other element
a.slice('::2').toArray();     // [0, 2, 4, 6, 8]

// Reversed
a.slice('::-1').toArray();    // [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

// Elements 2 through 7, step 2
a.slice('2:8:2').toArray();   // [2, 4, 6]

Multi-dimensional slicing

Pass one string argument per dimension:

const m = np.array([
  [0, 1, 2, 3],
  [4, 5, 6, 7],
  [8, 9, 10, 11],
]);
// shape [3, 4]

// First 2 rows, all columns
m.slice('0:2', ':').toArray();
// [[0, 1, 2, 3],
//  [4, 5, 6, 7]]

// All rows, columns 1 and 2
m.slice(':', '1:3').toArray();
// [[1, 2],
//  [5, 6],
//  [9, 10]]

// Single row (integer index reduces dimension)
m.slice('1').toArray();       // [4, 5, 6, 7]  (1-D result)

// Submatrix: rows 0-1, columns 2-3
m.slice('0:2', '2:4').toArray();
// [[2, 3],
//  [6, 7]]

When you pass an integer as a string (e.g. '1'), that dimension is removed from the result, just like NumPy’s integer indexing. A range like '1:2' keeps the dimension.

Negative indices

Negative indices count from the end, just like Python:

const a = np.arange(0, 10);

a.slice('-1').toArray();      // 9 (scalar -- dimension removed)
a.slice('-3:').toArray();     // [7, 8, 9]
a.slice(':-2').toArray();     // [0, 1, 2, 3, 4, 5, 6, 7]

const m = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
m.slice('-1').toArray();      // [7, 8, 9]  (last row)
m.slice(':', '-1').toArray(); // [3, 6, 9]  (last column, 1-D)

Element access: `get()` and `set()`

For reading or writing individual elements, use get() and set() with an array of indices:

const m = np.array([[10, 20, 30], [40, 50, 60]]);

// Read element at row 0, column 2
m.get([0, 2]);  // 30

// Write element at row 1, column 1
m.set([1, 1], 99);
m.get([1, 1]);  // 99

// Negative indices work here too
m.get([0, -1]);   // 30  (last column of first row)
m.get([-1, -1]);  // 60  (last element)

The get() and set() methods require one index per dimension. Passing the wrong number of indices throws an error.

Convenience methods: `row()`, `col()`, `rows()`, `cols()`

For 2-D arrays, numpy-ts provides shorthand methods that are cleaner than manual slicing:

const m = np.array([
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9],
]);

// Single row or column
m.row(0).toArray();        // [1, 2, 3]
m.row(-1).toArray();       // [7, 8, 9]
m.col(1).toArray();        // [2, 5, 8]

// Range of rows or columns
m.rows(0, 2).toArray();   // [[1, 2, 3], [4, 5, 6]]
m.cols(1, 3).toArray();   // [[2, 3], [5, 6], [8, 9]]

Method	Equivalent	Returns
`row(i)`	`.slice(String(i), ':')`	1-D array (single row)
`col(j)`	`.slice(':', String(j))`	1-D array (single column)
`rows(start, stop)`	`.slice(` ${start}:$ `, ':')`	2-D sub-matrix
`cols(start, stop)`	`.slice(':',` ${start}:$ `)`	2-D sub-matrix

These methods require at least 2 dimensions. Calling row() on a 1-D array throws an error.

Fancy indexing: `take` and `put`

`take(indices, axis?)`

Select elements at arbitrary positions along an axis. Returns a new array (not a view):

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

// Take specific elements
np.take(a, [0, 2, 4]).toArray();    // [10, 30, 50]
np.take(a, [4, 3, 2, 1, 0]).toArray();  // [50, 40, 30, 20, 10] (reversed)

// Take from a 2-D array along axis 0 (rows)
const m = np.array([[1, 2], [3, 4], [5, 6]]);
np.take(m, [0, 2], 0).toArray();   // [[1, 2], [5, 6]]

// Also available as a method
a.take([1, 3]).toArray();           // [20, 40]

`put(indices, values)`

Modify elements at specified flat indices in-place:

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

// Also available as a method
a.put([0, 4], np.array([99, 99]));
a.toArray();  // [99, 10, 0, 20, 99]

Boolean indexing: `bindex`

Select elements where a boolean mask is true. Returns a new 1-D array containing only the matching elements:

const a = np.array([10, 20, 30, 40, 50]);
const mask = np.array([1, 0, 1, 0, 1], { dtype: 'bool' });

// Using the function
np.bindex(a, mask).toArray();    // [10, 30, 50]

// Using the method
a.bindex(mask).toArray();        // [10, 30, 50]

// Common pattern: create mask from a comparison
const data = np.array([1, -2, 3, -4, 5]);
const positive = np.greater(data, 0);  // bool array: [1, 0, 1, 0, 1]
data.bindex(positive).toArray();        // [1, 3, 5]

Integer array indexing: `iindex`

Select elements using an array of integer indices along a given axis. Similar to NumPy’s fancy integer array indexing:

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

// Select by index array
a.iindex([3, 1, 4]).toArray();       // [40, 20, 50]

// Duplicate indices are allowed
a.iindex([0, 0, 2, 2]).toArray();    // [10, 10, 30, 30]

// On a 2-D array, along axis 0 (default)
const m = np.array([[1, 2], [3, 4], [5, 6]]);
m.iindex([2, 0]).toArray();          // [[5, 6], [1, 2]]

// Along axis 1 (columns)
m.iindex([1, 0], 1).toArray();       // [[2, 1], [4, 3], [6, 5]]

Conditional selection: `where`

The where function selects elements from one of two arrays based on a condition:

const condition = np.array([1, 0, 1, 0], { dtype: 'bool' });
const x = np.array([1, 2, 3, 4]);
const y = np.array([10, 20, 30, 40]);

np.where(condition, x, y).toArray();  // [1, 20, 3, 40]

When called with only a condition, where returns the indices of non-zero elements:

const a = np.array([0, 5, 0, 3, 0, 1]);
const [indices] = np.where(a);
indices.toArray();  // [1, 3, 5]

Views vs copies

Understanding when an operation returns a view (shared data) versus a copy (new data) is important for both correctness and performance: Views (shared memory):

slice() — all slicing operations
T / transpose()
reshape() (when the array is C-contiguous)
squeeze() / expand_dims()
broadcast_to()

Copies (new data):

flatten() / copy()
take() / iindex() / bindex()
Arithmetic operations (add, multiply, etc.)
sort(), argsort()

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

// Slicing returns a view
const view = a.slice('1:4');
view.set([0], 99);
a.toArray();  // [1, 99, 3, 4, 5]  -- modified!

// Flatten returns a copy
const flat = np.array([[1, 2], [3, 4]]).flatten();
flat.set([0], 99);
// Original is NOT affected

Check arr.base to determine if an array is a view. If base is not null, the array shares data with its base.

Summary: choosing the right tool

Task	Method	Returns
Contiguous sub-array	`.slice('0:5')`	View
Single element (read)	`.get([i, j])`	Scalar
Single element (write)	`.set([i, j], val)`	Void (in-place)
Single row/column	`.row(i)`, `.col(j)`	View
Row/column range	`.rows(a, b)`, `.cols(a, b)`	View
Arbitrary integer positions	`.take(indices)` or `.iindex(indices)`	Copy
In-place by flat index	`.put(indices, values)`	Void (in-place)
Boolean mask selection	`.bindex(mask)`	Copy
Conditional pick from two arrays	`np.where(cond, x, y)`	Copy

numpy-ts

Getting Started

Guides

Resources

Slicing & Indexing

Python vs TypeScript syntax

String slice syntax

Basic slicing

Multi-dimensional slicing

Negative indices

Element access: `get()` and `set()`

Convenience methods: `row()`, `col()`, `rows()`, `cols()`

Fancy indexing: `take` and `put`

`take(indices, axis?)`

`put(indices, values)`

Boolean indexing: `bindex`

Integer array indexing: `iindex`

Conditional selection: `where`

Views vs copies

Summary: choosing the right tool

Next steps

Broadcasting

Array Basics

​Python vs TypeScript syntax

​String slice syntax

​Basic slicing

​Multi-dimensional slicing

​Negative indices

​Element access: get() and set()

​Convenience methods: row(), col(), rows(), cols()

​Fancy indexing: take and put

​take(indices, axis?)

​put(indices, values)

​Boolean indexing: bindex

​Integer array indexing: iindex

​Conditional selection: where

​Views vs copies

​Summary: choosing the right tool

​Next steps

Broadcasting

Array Basics

Python vs TypeScript syntax

String slice syntax

Basic slicing

Multi-dimensional slicing

Negative indices

Element access: `get()` and `set()`

Convenience methods: `row()`, `col()`, `rows()`, `cols()`

Fancy indexing: `take` and `put`

`take(indices, axis?)`

`put(indices, values)`

Boolean indexing: `bindex`

Integer array indexing: `iindex`

Conditional selection: `where`

Views vs copies

Summary: choosing the right tool

Next steps