Documentation Index
Fetch the complete documentation index at: https://numpyts.dev/llms.txt
Use this file to discover all available pages before exploring further.
Statistics
Functions for computing histograms, correlation, convolution, covariance, and numerical integration.
histogram
Compute the histogram of a dataset.
function histogram(
a: ArrayLike,
bins?: number | ArrayLike | BinStrategyString,
range?: [number, number],
density?: boolean,
weights?: ArrayLike
): [NDArray, NDArray];
| Parameter | Type | Default | Description |
|---|
a | ArrayLike | — | Input data (flattened). |
bins | number | ArrayLike | 10 | If an integer, the number of equal-width bins. If an array, the bin edges (length nbins + 1). |
range | [number, number] | undefined | Lower and upper range of the bins. If undefined, uses [min(a), max(a)]. |
density | boolean | false | If true, the result is normalized so the integral over the range equals 1. |
weights | ArrayLike | undefined | Optional weights for each sample in a. |
[counts, bin_edges] where counts has shape [nbins] and bin_edges has shape [nbins + 1].
import { histogram } from 'numpy-ts';
const [counts, edges] = histogram([1, 2, 1, 3, 2, 2], 3);
// counts: array([2, 3, 1])
// edges: array([1, 1.6667, 2.3333, 3])
const [density, _] = histogram([1, 2, 1, 3, 2, 2], 3, undefined, true);
// density values integrate to 1
histogram2d
Compute the bi-dimensional histogram of two data samples.
function histogram2d(
x: ArrayLike,
y: ArrayLike,
bins?: number | [number, number] | [ArrayLike, ArrayLike],
range?: [[number, number], [number, number]],
density?: boolean,
weights?: ArrayLike
): [NDArray, NDArray, NDArray];
| Parameter | Type | Default | Description |
|---|
x | ArrayLike | — | Array of x-coordinates. |
y | ArrayLike | — | Array of y-coordinates (same length as x). |
bins | number | [number, number] | 10 | Number of bins for each dimension, or a pair [nx, ny]. |
range | [[number, number], [number, number]] | undefined | Range for each dimension: [[xmin, xmax], [ymin, ymax]]. |
density | boolean | false | If true, normalize the histogram. |
weights | ArrayLike | undefined | Optional weights for each paired sample. |
[H, xedges, yedges] where H has shape [nx, ny].
import { histogram2d } from 'numpy-ts';
const x = [1, 2, 3, 4, 5];
const y = [5, 4, 3, 2, 1];
const [H, xedges, yedges] = histogram2d(x, y, 3);
// H: 2D array of counts, shape [3, 3]
// xedges: array of length 4
// yedges: array of length 4
histogramdd
Compute the multidimensional histogram of some data.
function histogramdd(
sample: ArrayLike,
bins?: number | number[],
range?: [number, number][],
density?: boolean,
weights?: ArrayLike
): [NDArray, NDArray[]];
| Parameter | Type | Default | Description |
|---|
sample | ArrayLike | — | Data as an (N, D) array, where N is the number of samples and D is the number of dimensions. |
bins | number | number[] | 10 | Number of bins for each dimension. A single integer applies to all dimensions. |
range | [number, number][] | undefined | Range [min, max] for each dimension. |
density | boolean | false | If true, normalize the histogram. |
weights | ArrayLike | undefined | Optional weights for each sample. |
[H, edges] where H is the D-dimensional count array and edges is an array of D edge arrays.
import { array, histogramdd } from 'numpy-ts';
const sample = array([[0, 0], [1, 1], [2, 2], [0, 1]]);
const [H, edges] = histogramdd(sample, 3);
// H: 3x3 array of counts
// edges: [xedges, yedges]
histogram_bin_edges
Compute the bin edges for a histogram without computing the histogram itself. Useful for sharing bin edges across multiple histograms.
function histogram_bin_edges(
a: ArrayLike,
bins?: number | BinStrategyString,
range?: [number, number],
weights?: ArrayLike
): NDArray;
| Parameter | Type | Default | Description |
|---|
a | ArrayLike | — | Input data. |
bins | number | string | 10 | Number of bins, or a string naming a binning strategy (e.g., 'auto', 'sturges', 'sqrt'). |
range | [number, number] | undefined | Lower and upper range of the bins. |
weights | ArrayLike | undefined | Optional sample weights used for automatic bin edge selection. |
NDArray of bin edges with length nbins + 1.
import { histogram_bin_edges } from 'numpy-ts';
const edges = histogram_bin_edges([1, 2, 3, 4, 5], 5);
// array([1, 1.8, 2.6, 3.4, 4.2, 5])
bincount
Count occurrences of each value in an array of non-negative integers.
function bincount(
x: ArrayLike,
weights?: ArrayLike,
minlength?: number
): NDArray;
| Parameter | Type | Default | Description |
|---|
x | ArrayLike | — | Array of non-negative integers. |
weights | ArrayLike | undefined | Weights for each value. If provided, the result is the sum of weights for each bin instead of counts. |
minlength | number | 0 | Minimum number of bins in the output. |
NDArray of length max(x) + 1 (or minlength, whichever is larger).
import { bincount } from 'numpy-ts';
bincount([0, 1, 1, 2, 2, 2]); // array([1, 2, 3])
bincount([0, 1, 1, 2], [0.5, 1, 1, 2]); // array([0.5, 2, 2]) (weighted)
bincount([3], undefined, 6); // array([0, 0, 0, 1, 0, 0])
digitize
Return the indices of the bins to which each value belongs.
function digitize(
x: ArrayLike,
bins: ArrayLike,
right?: boolean
): NDArray;
| Parameter | Type | Default | Description |
|---|
x | ArrayLike | — | Input array to be binned. |
bins | ArrayLike | — | Array of bin edges (must be monotonically increasing or decreasing). |
right | boolean | false | If false, the intervals are left-closed [a, b). If true, the intervals are right-closed (a, b]. |
NDArray of bin indices. An index i means bins[i-1] <= x < bins[i] (when right=false).
import { digitize } from 'numpy-ts';
const bins = [0, 1, 2, 3];
digitize([0.5, 1.5, 2.5, 3.5], bins); // array([1, 2, 3, 4])
digitize([-0.5], bins); // array([0])
correlate
Cross-correlation of two 1-dimensional sequences.
function correlate(
a: ArrayLike,
v: ArrayLike,
mode?: 'valid' | 'same' | 'full'
): NDArray;
| Parameter | Type | Default | Description |
|---|
a | ArrayLike | — | First input sequence. |
v | ArrayLike | — | Second input sequence. |
mode | 'valid' | 'same' | 'full' | 'valid' | 'valid': only where the sequences fully overlap. 'same': output length equals the longer input. 'full': full cross-correlation. |
NDArray containing the cross-correlation result.
import { correlate } from 'numpy-ts';
correlate([1, 2, 3], [0, 1, 0.5]); // array([3.5]) (valid)
correlate([1, 2, 3], [0, 1, 0.5], 'full'); // array([0.5, 2, 3.5, 3, 0])
convolve
Discrete, linear convolution of two 1-dimensional sequences.
function convolve(
a: ArrayLike,
v: ArrayLike,
mode?: 'valid' | 'same' | 'full'
): NDArray;
| Parameter | Type | Default | Description |
|---|
a | ArrayLike | — | First input sequence. |
v | ArrayLike | — | Second input sequence. |
mode | 'valid' | 'same' | 'full' | 'full' | 'valid': only where the sequences fully overlap. 'same': output length equals the longer input. 'full': full convolution. |
NDArray containing the convolution result.
import { convolve } from 'numpy-ts';
convolve([1, 2, 3], [0, 1, 0.5]); // array([0, 1, 2.5, 4, 1.5]) (full)
convolve([1, 2, 3], [0, 1, 0.5], 'same'); // array([1, 2.5, 4])
cov
Estimate a covariance matrix.
function cov(
m: ArrayLike,
y?: ArrayLike,
rowvar?: boolean,
bias?: boolean,
ddof?: number
): NDArray;
| Parameter | Type | Default | Description |
|---|
m | ArrayLike | — | A 1-D or 2-D array of variables and observations. Each row represents a variable; each column an observation (when rowvar=true). |
y | ArrayLike | undefined | Additional set of variables and observations. Same form as m. |
rowvar | boolean | true | If true, each row is a variable. If false, each column is a variable. |
bias | boolean | false | If false, normalize by N - 1 (unbiased). If true, normalize by N. |
ddof | number | undefined | Override the default degrees of freedom. If provided, bias is ignored and the normalization factor is N - ddof. |
NDArray — the covariance matrix.
import { array, cov } from 'numpy-ts';
const x = array([1, 2, 3, 4, 5]);
cov(x); // array([[2.5]])
const m = array([[1, 2, 3], [4, 5, 6]]);
cov(m);
// array([[1, 1],
// [1, 1]])
corrcoef
Return Pearson correlation coefficients.
function corrcoef(
x: ArrayLike,
y?: ArrayLike,
rowvar?: boolean
): NDArray;
| Parameter | Type | Default | Description |
|---|
x | ArrayLike | — | A 1-D or 2-D array of variables and observations. |
y | ArrayLike | undefined | Additional set of variables and observations. |
rowvar | boolean | true | If true, each row is a variable. If false, each column is a variable. |
NDArray — the correlation coefficient matrix, with values in [-1, 1].
import { array, corrcoef } from 'numpy-ts';
const x = array([1, 2, 3, 4, 5]);
const y = array([5, 4, 3, 2, 1]);
corrcoef(x, y);
// array([[ 1, -1],
// [-1, 1]])
trapezoid
Integrate along the given axis using the composite trapezoidal rule.
function trapezoid(
y: ArrayLike,
x?: ArrayLike,
dx?: number,
axis?: number
): number | NDArray;
| Parameter | Type | Default | Description |
|---|
y | ArrayLike | — | Input array of values to integrate. |
x | ArrayLike | undefined | Sample points corresponding to y. If undefined, spacing is assumed uniform with interval dx. |
dx | number | 1 | Spacing between sample points when x is not provided. |
axis | number | undefined | Axis along which to integrate. |
number when integrating a 1-D array, NDArray when integrating along an axis of a multi-dimensional array.
import { array, trapezoid } from 'numpy-ts';
trapezoid(array([1, 2, 3])); // 4 (area under [1,2,3] with dx=1)
trapezoid(array([1, 2, 3]), undefined, 0.5); // 2 (dx=0.5)
trapezoid(array([1, 2, 3]), array([0, 1, 4])); // 8.5 (non-uniform spacing)
