numpy-ts 0.11.0 → 0.13.0

package/dist/types/common/ops/random.d.ts

@@ -0,0 +1,376 @@
+/**
+ * Random number generation module
+ *
+ * Implements NumPy-compatible random functions:
+ * - Legacy API (np.random.seed, random, rand, uniform, etc.) uses MT19937
+ * - Modern API (np.random.default_rng) uses PCG64 with SeedSequence
+ *
+ * Both implementations produce identical output to NumPy when seeded.
+ */
+import { ArrayStorage } from '../storage';
+import { type DType } from '../dtype';
+/**
+ * Random number generator class (matches NumPy's Generator from default_rng)
+ */
+export declare class Generator {
+    private _pcgState;
+    constructor(seedValue?: number);
+    private _randomFloat;
+    random(size?: number | number[]): ArrayStorage | number;
+    integers(low: number, high?: number, size?: number | number[]): ArrayStorage | number;
+    standard_normal(size?: number | number[]): ArrayStorage | number;
+    normal(loc?: number, scale?: number, size?: number | number[]): ArrayStorage | number;
+    uniform(low?: number, high?: number, size?: number | number[]): ArrayStorage | number;
+    choice(a: number | ArrayStorage, size?: number | number[], replace?: boolean, p?: ArrayStorage | number[]): ArrayStorage | number;
+    permutation(x: number | ArrayStorage): ArrayStorage;
+    shuffle(x: ArrayStorage): void;
+    exponential(scale?: number, size?: number | number[]): ArrayStorage | number;
+    poisson(lam?: number, size?: number | number[]): ArrayStorage | number;
+    binomial(n: number, p: number, size?: number | number[]): ArrayStorage | number;
+}
+/**
+ * Create a new Generator instance (matches np.random.default_rng)
+ * @param seedValue - Optional seed value
+ */
+export declare function default_rng(seedValue?: number): Generator;
+/**
+ * Seed the random number generator (legacy API)
+ * @param seedValue - Seed value (integer)
+ */
+export declare function seed(seedValue?: number | null): void;
+/**
+ * Get the internal state of the random number generator
+ * @returns State object that can be used with set_state
+ */
+export declare function get_state(): {
+    mt: number[];
+    mti: number;
+};
+/**
+ * Set the internal state of the random number generator
+ * @param state - State object from get_state
+ */
+export declare function set_state(state: {
+    mt: number[];
+    mti: number;
+}): void;
+/**
+ * Generate random floats in the half-open interval [0.0, 1.0)
+ * @param size - Output shape. If not provided, returns a single float.
+ */
+export declare function random(size?: number | number[]): ArrayStorage | number;
+/**
+ * Random values in a given shape (alias for random with shape)
+ * @param d0, d1, ..., dn - The dimensions of the returned array
+ */
+export declare function rand(...shape: number[]): ArrayStorage | number;
+/**
+ * Return random floats from standard normal distribution
+ * @param d0, d1, ..., dn - The dimensions of the returned array
+ */
+export declare function randn(...shape: number[]): ArrayStorage | number;
+/**
+ * Return random integers from low (inclusive) to high (exclusive)
+ * @param low - Lowest integer (or high if high is not provided)
+ * @param high - One above the highest integer (optional)
+ * @param size - Output shape
+ * @param dtype - Output dtype (default 'int64')
+ */
+export declare function randint(low: number, high?: number | null, size?: number | number[], dtype?: DType): ArrayStorage | number;
+/**
+ * Draw samples from a uniform distribution
+ * @param low - Lower boundary (default 0)
+ * @param high - Upper boundary (default 1)
+ * @param size - Output shape
+ */
+export declare function uniform(low?: number, high?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a normal (Gaussian) distribution
+ * @param loc - Mean of the distribution (default 0)
+ * @param scale - Standard deviation (default 1)
+ * @param size - Output shape
+ */
+export declare function normal(loc?: number, scale?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a standard normal distribution (mean=0, std=1)
+ * @param size - Output shape
+ */
+export declare function standard_normal(size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from an exponential distribution
+ * @param scale - The scale parameter (beta = 1/lambda) (default 1)
+ * @param size - Output shape
+ */
+export declare function exponential(scale?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a Poisson distribution
+ * @param lam - Expected number of events (lambda) (default 1)
+ * @param size - Output shape
+ */
+export declare function poisson(lam?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a binomial distribution
+ * @param n - Number of trials
+ * @param p - Probability of success
+ * @param size - Output shape
+ */
+export declare function binomial(n: number, p: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Generate a random sample from a given 1-D array
+ * @param a - Input array or int. If int, samples from arange(a)
+ * @param size - Output shape
+ * @param replace - Whether sampling with replacement (default true)
+ * @param p - Probabilities associated with each entry
+ */
+export declare function choice(a: number | ArrayStorage, size?: number | number[], replace?: boolean, p?: ArrayStorage | number[]): ArrayStorage | number;
+/**
+ * Randomly permute a sequence, or return a permuted range
+ * @param x - Input array or int. If int, returns permutation of arange(x)
+ */
+export declare function permutation(x: number | ArrayStorage): ArrayStorage;
+/**
+ * Modify a sequence in-place by shuffling its contents
+ * @param x - Array to be shuffled
+ */
+export declare function shuffle(x: ArrayStorage): void;
+/**
+ * Return random floats in the half-open interval [0.0, 1.0)
+ * Alias for random()
+ * @param size - Output shape
+ */
+export declare function random_sample(size?: number | number[]): ArrayStorage | number;
+/**
+ * Return random floats in the half-open interval [0.0, 1.0)
+ * Alias for random()
+ * @param size - Output shape
+ */
+export declare function ranf(size?: number | number[]): ArrayStorage | number;
+/**
+ * Return random floats in the half-open interval [0.0, 1.0)
+ * Alias for random()
+ * @param size - Output shape
+ */
+export declare function sample(size?: number | number[]): ArrayStorage | number;
+/**
+ * Return random integers between low and high, inclusive (DEPRECATED)
+ * @deprecated Use randint instead
+ * @param low - Lowest integer
+ * @param high - Highest integer (inclusive, unlike randint)
+ * @param size - Output shape
+ */
+export declare function random_integers(low: number, high?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Return random bytes
+ * @param length - Number of bytes to return
+ */
+export declare function bytes(length: number): Uint8Array;
+interface BitGenerator {
+    name: string;
+    state: object;
+}
+/**
+ * Get the current bit generator
+ * @returns The current bit generator object
+ */
+export declare function get_bit_generator(): BitGenerator;
+/**
+ * Set the bit generator
+ * @param bitgen - The bit generator to use
+ */
+export declare function set_bit_generator(bitgen: BitGenerator): void;
+/**
+ * Draw samples from the standard exponential distribution (scale=1)
+ * @param size - Output shape
+ */
+export declare function standard_exponential(size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a standard gamma distribution
+ * Uses Marsaglia and Tsang's method
+ * @param shape - Shape parameter (alpha, must be > 0)
+ * @param size - Output shape
+ */
+export declare function standard_gamma(shape: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a standard Cauchy distribution
+ * @param size - Output shape
+ */
+export declare function standard_cauchy(size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a standard Student's t distribution with df degrees of freedom
+ * @param df - Degrees of freedom (must be > 0)
+ * @param size - Output shape
+ */
+export declare function standard_t(df: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a Gamma distribution
+ * @param shape - Shape parameter (k, alpha) (must be > 0)
+ * @param scale - Scale parameter (theta) (default 1.0)
+ * @param size - Output shape
+ */
+export declare function gamma(shape: number, scale?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a Beta distribution
+ * @param a - Alpha parameter (must be > 0)
+ * @param b - Beta parameter (must be > 0)
+ * @param size - Output shape
+ */
+export declare function beta(a: number, b: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a Laplace (double exponential) distribution
+ * @param loc - Location parameter (default 0)
+ * @param scale - Scale parameter (default 1)
+ * @param size - Output shape
+ */
+export declare function laplace(loc?: number, scale?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a logistic distribution
+ * @param loc - Location parameter (default 0)
+ * @param scale - Scale parameter (default 1)
+ * @param size - Output shape
+ */
+export declare function logistic(loc?: number, scale?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a log-normal distribution
+ * @param mean - Mean of the underlying normal distribution (default 0)
+ * @param sigma - Standard deviation of the underlying normal (default 1)
+ * @param size - Output shape
+ */
+export declare function lognormal(mean?: number, sigma?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a Gumbel distribution
+ * @param loc - Location parameter (default 0)
+ * @param scale - Scale parameter (default 1)
+ * @param size - Output shape
+ */
+export declare function gumbel(loc?: number, scale?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a Pareto II (Lomax) distribution
+ * @param a - Shape parameter (must be > 0)
+ * @param size - Output shape
+ */
+export declare function pareto(a: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a power distribution with positive exponent a-1
+ * @param a - Shape parameter (must be > 0)
+ * @param size - Output shape
+ */
+export declare function power(a: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a Rayleigh distribution
+ * @param scale - Scale parameter (default 1)
+ * @param size - Output shape
+ */
+export declare function rayleigh(scale?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a triangular distribution
+ * @param left - Lower limit
+ * @param mode - Mode (peak)
+ * @param right - Upper limit
+ * @param size - Output shape
+ */
+export declare function triangular(left: number, mode: number, right: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a Wald (inverse Gaussian) distribution
+ * @param mean - Mean of distribution (must be > 0)
+ * @param scale - Scale parameter (must be > 0)
+ * @param size - Output shape
+ */
+export declare function wald(mean: number, scale: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a Weibull distribution
+ * @param a - Shape parameter (must be > 0)
+ * @param size - Output shape
+ */
+export declare function weibull(a: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a chi-square distribution
+ * @param df - Degrees of freedom (must be > 0)
+ * @param size - Output shape
+ */
+export declare function chisquare(df: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a noncentral chi-square distribution
+ * @param df - Degrees of freedom (must be > 0)
+ * @param nonc - Non-centrality parameter (must be >= 0)
+ * @param size - Output shape
+ */
+export declare function noncentral_chisquare(df: number, nonc: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from an F distribution
+ * @param dfnum - Degrees of freedom in numerator (must be > 0)
+ * @param dfden - Degrees of freedom in denominator (must be > 0)
+ * @param size - Output shape
+ */
+export declare function f(dfnum: number, dfden: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a noncentral F distribution
+ * @param dfnum - Degrees of freedom in numerator (must be > 0)
+ * @param dfden - Degrees of freedom in denominator (must be > 0)
+ * @param nonc - Non-centrality parameter (must be >= 0)
+ * @param size - Output shape
+ */
+export declare function noncentral_f(dfnum: number, dfden: number, nonc: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a geometric distribution
+ * @param p - Probability of success (0 < p <= 1)
+ * @param size - Output shape
+ */
+export declare function geometric(p: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a hypergeometric distribution
+ * @param ngood - Number of good elements in population
+ * @param nbad - Number of bad elements in population
+ * @param nsample - Number of items to sample
+ * @param size - Output shape
+ */
+export declare function hypergeometric(ngood: number, nbad: number, nsample: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a logarithmic series distribution
+ * @param p - Shape parameter (0 < p < 1)
+ * @param size - Output shape
+ */
+export declare function logseries(p: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a negative binomial distribution
+ * @param n - Number of successes (must be > 0)
+ * @param p - Probability of success (0 < p <= 1)
+ * @param size - Output shape
+ */
+export declare function negative_binomial(n: number, p: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a Zipf distribution
+ * @param a - Distribution parameter (must be > 1)
+ * @param size - Output shape
+ */
+export declare function zipf(a: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a multinomial distribution
+ * @param n - Number of experiments
+ * @param pvals - Probabilities of each category (must sum to 1)
+ * @param size - Output shape (number of experiments to run)
+ */
+export declare function multinomial(n: number, pvals: number[] | ArrayStorage, size?: number | number[]): ArrayStorage;
+/**
+ * Draw samples from a multivariate normal distribution
+ * @param mean - Mean of the distribution (1-D array of length N)
+ * @param cov - Covariance matrix (N x N array)
+ * @param size - Number of samples to draw
+ * @param check_valid - Check validity of covariance matrix (default 'warn')
+ * @param tol - Tolerance for checking positive semi-definiteness
+ */
+export declare function multivariate_normal(mean: number[] | ArrayStorage, cov: number[][] | ArrayStorage, size?: number | number[], check_valid?: 'warn' | 'raise' | 'ignore', tol?: number): ArrayStorage;
+/**
+ * Draw samples from a Dirichlet distribution
+ * @param alpha - Concentration parameters (must all be > 0)
+ * @param size - Number of samples to draw
+ */
+export declare function dirichlet(alpha: number[] | ArrayStorage, size?: number | number[]): ArrayStorage;
+/**
+ * Draw samples from a von Mises distribution
+ * @param mu - Mode (center) of the distribution (in radians)
+ * @param kappa - Concentration parameter (must be >= 0)
+ * @param size - Output shape
+ */
+export declare function vonmises(mu: number, kappa: number, size?: number | number[]): ArrayStorage | number;
+export {};
+//# sourceMappingURL=random.d.ts.map

package/dist/types/{ops → common/ops}/reduction.d.ts

@@ -4,8 +4,8 @@
  * Pure functions for reducing arrays along axes.
  * @module ops/reduction
  */
-import { ArrayStorage } from '../core/storage';
-import { Complex } from '../core/complex';
+import { ArrayStorage } from '../storage';
+import { Complex } from '../complex';
 /**
  * Sum array elements over a given axis
  */
@@ -142,4 +142,12 @@ export declare function nancumprod(storage: ArrayStorage, axis?: number): ArrayS
  * Compute median ignoring NaN values
  */
 export declare function nanmedian(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Compute the q-th quantile of data along specified axis, ignoring NaNs
+ */
+export declare function nanquantile(storage: ArrayStorage, q: number, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Compute the q-th percentile of data along specified axis, ignoring NaNs
+ */
+export declare function nanpercentile(storage: ArrayStorage, q: number, axis?: number, keepdims?: boolean): ArrayStorage | number;
 //# sourceMappingURL=reduction.d.ts.map

package/dist/types/{ops → common/ops}/rounding.d.ts

@@ -7,7 +7,7 @@
  * Note: Rounding operations are not defined for complex numbers.
  * All functions throw TypeError for complex dtypes.
  */
-import { ArrayStorage } from '../core/storage';
+import { ArrayStorage } from '../storage';
 /**
  * Round an array to the given number of decimals
  */

package/dist/types/common/ops/sets.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Set operations
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * Find the unique elements of an array
+ */
+export declare function unique(a: ArrayStorage, returnIndex?: boolean, returnInverse?: boolean, returnCounts?: boolean): ArrayStorage | {
+    values: ArrayStorage;
+    indices?: ArrayStorage;
+    inverse?: ArrayStorage;
+    counts?: ArrayStorage;
+};
+/**
+ * Test whether each element of a 1-D array is also present in a second array
+ */
+export declare function in1d(ar1: ArrayStorage, ar2: ArrayStorage): ArrayStorage;
+/**
+ * Find the intersection of two arrays
+ */
+export declare function intersect1d(ar1: ArrayStorage, ar2: ArrayStorage): ArrayStorage;
+/**
+ * Test whether each element of an ND array is also present in a second array
+ */
+export declare function isin(element: ArrayStorage, testElements: ArrayStorage): ArrayStorage;
+/**
+ * Find the set difference of two arrays
+ */
+export declare function setdiff1d(ar1: ArrayStorage, ar2: ArrayStorage): ArrayStorage;
+/**
+ * Find the set exclusive-or of two arrays
+ */
+export declare function setxor1d(ar1: ArrayStorage, ar2: ArrayStorage): ArrayStorage;
+/**
+ * Find the union of two arrays
+ */
+export declare function union1d(ar1: ArrayStorage, ar2: ArrayStorage): ArrayStorage;
+/**
+ * Trim leading and/or trailing zeros from a 1-D array.
+ *
+ * @param filt - Input 1-D array
+ * @param trim - 'fb' to trim front and back, 'f' for front only, 'b' for back only (default: 'fb')
+ * @returns Trimmed array
+ */
+export declare function trim_zeros(filt: ArrayStorage, trim?: 'f' | 'b' | 'fb'): ArrayStorage;
+/**
+ * Find the unique elements of an array, returning all optional outputs.
+ *
+ * @param x - Input array (flattened for uniqueness)
+ * @returns Object with values, indices, inverse_indices, and counts
+ */
+export declare function unique_all(x: ArrayStorage): {
+    values: ArrayStorage;
+    indices: ArrayStorage;
+    inverse_indices: ArrayStorage;
+    counts: ArrayStorage;
+};
+/**
+ * Find the unique elements of an array and their counts.
+ *
+ * @param x - Input array (flattened for uniqueness)
+ * @returns Object with values and counts
+ */
+export declare function unique_counts(x: ArrayStorage): {
+    values: ArrayStorage;
+    counts: ArrayStorage;
+};
+/**
+ * Find the unique elements of an array and their inverse indices.
+ *
+ * @param x - Input array (flattened for uniqueness)
+ * @returns Object with values and inverse_indices
+ */
+export declare function unique_inverse(x: ArrayStorage): {
+    values: ArrayStorage;
+    inverse_indices: ArrayStorage;
+};
+/**
+ * Find the unique elements of an array (values only).
+ *
+ * This is equivalent to unique(x) but with a clearer name for the Array API.
+ *
+ * @param x - Input array (flattened for uniqueness)
+ * @returns Array of unique values, sorted
+ */
+export declare function unique_values(x: ArrayStorage): ArrayStorage;
+//# sourceMappingURL=sets.d.ts.map

package/dist/types/{ops → common/ops}/shape.d.ts

@@ -4,7 +4,7 @@
  * Pure functions for reshaping, transposing, and manipulating array dimensions.
  * @module ops/shape
  */
-import { ArrayStorage } from '../core/storage';
+import { ArrayStorage } from '../storage';
 /**
  * Reshape array to a new shape
  * Returns a view if array is C-contiguous, otherwise copies data
@@ -141,4 +141,17 @@ export declare function atleast2d(storages: ArrayStorage[]): ArrayStorage[];
  * Convert arrays to at least 3D
  */
 export declare function atleast3d(storages: ArrayStorage[]): ArrayStorage[];
+/**
+ * Alias for concatenate
+ */
+export declare function concat(storages: ArrayStorage[], axis?: number): ArrayStorage;
+/**
+ * Split an array into a sequence of sub-arrays along an axis (inverse of stack)
+ */
+export declare function unstack(storage: ArrayStorage, axis?: number): ArrayStorage[];
+/**
+ * Assemble an nd-array from nested lists of blocks
+ * For a simple list [a, b] of nD arrays, concatenates along the last axis (like np.block)
+ */
+export declare function block(storages: ArrayStorage[], _depth?: number): ArrayStorage;
 //# sourceMappingURL=shape.d.ts.map

package/dist/types/{ops → common/ops}/sorting.d.ts

@@ -4,7 +4,7 @@
  * Functions for sorting arrays, finding sorted indices, and searching.
  * @module ops/sorting
  */
-import { ArrayStorage } from '../core/storage';
+import { ArrayStorage } from '../storage';
 /**
  * Return a sorted copy of an array
  * @param storage - Input array storage

package/dist/types/{ops → common/ops}/statistics.d.ts

@@ -4,7 +4,7 @@
  * Pure functions for statistical analysis.
  * @module ops/statistics
  */
-import { ArrayStorage } from '../core/storage';
+import { ArrayStorage } from '../storage';
 /**
  * Count number of occurrences of each value in array of non-negative ints.
  *
@@ -105,4 +105,26 @@ export declare function cov(m: ArrayStorage, y?: ArrayStorage, rowvar?: boolean,
  * @returns Correlation coefficient matrix
  */
 export declare function corrcoef(x: ArrayStorage, y?: ArrayStorage, rowvar?: boolean): ArrayStorage;
+/**
+ * Compute the edges of the bins for histogram.
+ *
+ * This function computes the bin edges without computing the histogram itself.
+ *
+ * @param a - Input data (flattened if not 1D)
+ * @param bins - Number of bins (default: 10) or a string specifying the bin algorithm
+ * @param range - Lower and upper range of bins. If not provided, uses [a.min(), a.max()]
+ * @param weights - Optional weights for each data point (used for some algorithms)
+ * @returns Array of bin edges (length = bins + 1)
+ */
+export declare function histogram_bin_edges(a: ArrayStorage, bins?: number | 'auto' | 'fd' | 'doane' | 'scott' | 'stone' | 'rice' | 'sturges' | 'sqrt', range?: [number, number], _weights?: ArrayStorage): ArrayStorage;
+/**
+ * Integrate along the given axis using the composite trapezoidal rule.
+ *
+ * @param y - Input array to integrate
+ * @param x - Optional sample points corresponding to y values. If not provided, spacing is assumed to be 1.
+ * @param dx - Spacing between sample points when x is not given (default: 1.0)
+ * @param axis - The axis along which to integrate (default: -1, meaning last axis)
+ * @returns Definite integral approximated using the composite trapezoidal rule
+ */
+export declare function trapezoid(y: ArrayStorage, x?: ArrayStorage, dx?: number, axis?: number): ArrayStorage | number;
 //# sourceMappingURL=statistics.d.ts.map

package/dist/types/{ops → common/ops}/trig.d.ts

@@ -7,7 +7,7 @@
  * These functions are used by NDArray methods but are separated
  * to keep the codebase modular and testable.
  */
-import { ArrayStorage } from '../core/storage';
+import { ArrayStorage } from '../storage';
 /**
  * Sine of each element (element-wise)
  * NumPy behavior: Always promotes to float64 for integer types

package/dist/types/{core → common}/storage.d.ts

@@ -17,6 +17,7 @@ export declare class ArrayStorage {
     private _strides;
     private _offset;
     private _dtype;
+    private _isCContiguous;
     constructor(data: TypedArray, shape: readonly number[], strides: readonly number[], offset: number, dtype: DType);
     /**
      * Shape of the array

package/dist/types/core/advanced.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Advanced indexing and data manipulation functions
+ *
+ * Tree-shakeable standalone functions that wrap the underlying ops.
+ */
+import { NDArrayCore } from '../common/ndarray-core';
+import * as advancedOps from '../common/ops/advanced';
+/** Broadcast array to a new shape - returns a view */
+export declare function broadcast_to(a: NDArrayCore, shape: number[]): NDArrayCore;
+export declare function broadcast_arrays(...arrays: NDArrayCore[]): NDArrayCore[];
+export declare function broadcast_shapes(...shapes: number[][]): number[];
+export declare function take(a: NDArrayCore, indices: number[], axis?: number): NDArrayCore;
+export declare function put(a: NDArrayCore, indices: number[], values: NDArrayCore | number[]): void;
+export declare function take_along_axis(arr: NDArrayCore, indices: NDArrayCore, axis: number): NDArrayCore;
+export declare function put_along_axis(arr: NDArrayCore, indices: NDArrayCore, values: NDArrayCore, axis: number): void;
+export declare function choose(a: NDArrayCore, choices: NDArrayCore[]): NDArrayCore;
+export declare function compress(condition: NDArrayCore, a: NDArrayCore, axis?: number): NDArrayCore;
+/**
+ * Integer array indexing (fancy indexing)
+ *
+ * Select elements using an array of indices.
+ */
+export declare function iindex(a: NDArrayCore, indices: NDArrayCore | number[] | number[][], axis?: number): NDArrayCore;
+/**
+ * Boolean array indexing (fancy indexing with mask)
+ *
+ * Select elements where a boolean mask is true.
+ */
+export declare function bindex(a: NDArrayCore, mask: NDArrayCore, axis?: number): NDArrayCore;
+export declare function select(condlist: NDArrayCore[], choicelist: NDArrayCore[], defaultVal?: number): NDArrayCore;
+export declare function place(a: NDArrayCore, mask: NDArrayCore, vals: NDArrayCore): void;
+export declare function putmask(a: NDArrayCore, mask: NDArrayCore, values: NDArrayCore): void;
+export declare function copyto(dst: NDArrayCore, src: NDArrayCore | number | bigint): void;
+export declare function indices(dimensions: number[], dtype?: 'int32' | 'int64' | 'float64'): NDArrayCore;
+export declare function ix_(...args: NDArrayCore[]): NDArrayCore[];
+export declare function ravel_multi_index(multi_index: NDArrayCore[], dims: number[], mode?: 'raise' | 'wrap' | 'clip'): NDArrayCore;
+export declare function unravel_index(indices: NDArrayCore | number, shape: number[]): NDArrayCore[];
+export declare function diag_indices(n: number, ndim?: number): NDArrayCore[];
+export declare function diag_indices_from(a: NDArrayCore): NDArrayCore[];
+export declare function fill_diagonal(a: NDArrayCore, val: number, wrap?: boolean): void;
+export declare function tril_indices(n: number, k?: number, m?: number): NDArrayCore[];
+export declare function tril_indices_from(a: NDArrayCore, k?: number): NDArrayCore[];
+export declare function triu_indices(n: number, k?: number, m?: number): NDArrayCore[];
+export declare function triu_indices_from(a: NDArrayCore, k?: number): NDArrayCore[];
+export declare function mask_indices(n: number, mask_func: (n: number, k: number) => NDArrayCore, k?: number): NDArrayCore[];
+export declare function array_equal(a: NDArrayCore, b: NDArrayCore, equal_nan?: boolean): boolean;
+export declare function array_equiv(a: NDArrayCore, b: NDArrayCore): boolean;
+export declare function apply_along_axis(func1d: (arr: NDArrayCore) => NDArrayCore | number, axis: number, arr: NDArrayCore): NDArrayCore;
+export declare function apply_over_axes(func: (arr: NDArrayCore, axis: number) => NDArrayCore, a: NDArrayCore, axes: number[]): NDArrayCore;
+export declare function may_share_memory(a: NDArrayCore, b: NDArrayCore): boolean;
+export declare function shares_memory(a: NDArrayCore, b: NDArrayCore): boolean;
+export declare const geterr: typeof advancedOps.geterr;
+export declare const seterr: typeof advancedOps.seterr;
+//# sourceMappingURL=advanced.d.ts.map