numpy-ts 0.8.0 → 0.9.0

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

@@ -120,6 +120,66 @@ export declare class NDArray {
      * @returns New array with powered values
      */
     power(exponent: NDArray | number): NDArray;
+    /**
+     * Natural exponential (e^x) of each element
+     * Promotes integer types to float64
+     * @returns New array with exp values
+     */
+    exp(): NDArray;
+    /**
+     * Base-2 exponential (2^x) of each element
+     * Promotes integer types to float64
+     * @returns New array with exp2 values
+     */
+    exp2(): NDArray;
+    /**
+     * Exponential minus one (e^x - 1) of each element
+     * More accurate than exp(x) - 1 for small x
+     * Promotes integer types to float64
+     * @returns New array with expm1 values
+     */
+    expm1(): NDArray;
+    /**
+     * Natural logarithm (ln) of each element
+     * Promotes integer types to float64
+     * @returns New array with log values
+     */
+    log(): NDArray;
+    /**
+     * Base-2 logarithm of each element
+     * Promotes integer types to float64
+     * @returns New array with log2 values
+     */
+    log2(): NDArray;
+    /**
+     * Base-10 logarithm of each element
+     * Promotes integer types to float64
+     * @returns New array with log10 values
+     */
+    log10(): NDArray;
+    /**
+     * Natural logarithm of (1 + x) of each element
+     * More accurate than log(1 + x) for small x
+     * Promotes integer types to float64
+     * @returns New array with log1p values
+     */
+    log1p(): NDArray;
+    /**
+     * Logarithm of the sum of exponentials: log(exp(x1) + exp(x2))
+     * More numerically stable than computing the expression directly
+     * Promotes integer types to float64
+     * @param x2 - Second operand (array or scalar)
+     * @returns New array with logaddexp values
+     */
+    logaddexp(x2: NDArray | number): NDArray;
+    /**
+     * Logarithm base 2 of the sum of exponentials: log2(2^x1 + 2^x2)
+     * More numerically stable than computing the expression directly
+     * Promotes integer types to float64
+     * @param x2 - Second operand (array or scalar)
+     * @returns New array with logaddexp2 values
+     */
+    logaddexp2(x2: NDArray | number): NDArray;
     /**
      * Absolute value of each element
      * @returns New array with absolute values
@@ -135,6 +195,43 @@ export declare class NDArray {
      * @returns New array with signs
      */
     sign(): NDArray;
+    /**
+     * Round an array to the given number of decimals
+     * @param decimals - Number of decimal places to round to (default: 0)
+     * @returns New array with rounded values
+     */
+    around(decimals?: number): NDArray;
+    /**
+     * Round an array to the given number of decimals (alias for around)
+     * @param decimals - Number of decimal places to round to (default: 0)
+     * @returns New array with rounded values
+     */
+    round(decimals?: number): NDArray;
+    /**
+     * Return the ceiling of the input, element-wise
+     * @returns New array with ceiling values
+     */
+    ceil(): NDArray;
+    /**
+     * Round to nearest integer towards zero
+     * @returns New array with values truncated towards zero
+     */
+    fix(): NDArray;
+    /**
+     * Return the floor of the input, element-wise
+     * @returns New array with floor values
+     */
+    floor(): NDArray;
+    /**
+     * Round elements to the nearest integer
+     * @returns New array with rounded integer values
+     */
+    rint(): NDArray;
+    /**
+     * Return the truncated value of the input, element-wise
+     * @returns New array with truncated values
+     */
+    trunc(): NDArray;
     /**
      * Sine of each element (in radians)
      * Promotes integer types to float64
@@ -572,6 +669,13 @@ export declare class NDArray {
      * @returns Indices where values should be inserted
      */
     searchsorted(v: NDArray, side?: 'left' | 'right'): NDArray;
+    /**
+     * Calculate the n-th discrete difference along the given axis
+     * @param n - Number of times values are differenced (default: 1)
+     * @param axis - Axis along which to compute difference (default: -1)
+     * @returns Array of differences
+     */
+    diff(n?: number, axis?: number): NDArray;
     /**
      * Reshape array to a new shape
      * Returns a new array with the specified shape
@@ -1027,6 +1131,66 @@ export declare function sqrt(x: NDArray): NDArray;
  * @returns Array of x raised to exponent
  */
 export declare function power(x: NDArray, exponent: NDArray | number): NDArray;
+/**
+ * Element-wise natural exponential (e^x)
+ * @param x - Input array
+ * @returns Array of e^x values
+ */
+export declare function exp(x: NDArray): NDArray;
+/**
+ * Element-wise base-2 exponential (2^x)
+ * @param x - Input array
+ * @returns Array of 2^x values
+ */
+export declare function exp2(x: NDArray): NDArray;
+/**
+ * Element-wise exponential minus one (e^x - 1)
+ * More accurate than exp(x) - 1 for small x
+ * @param x - Input array
+ * @returns Array of expm1 values
+ */
+export declare function expm1(x: NDArray): NDArray;
+/**
+ * Element-wise natural logarithm (ln)
+ * @param x - Input array
+ * @returns Array of log values
+ */
+export declare function log(x: NDArray): NDArray;
+/**
+ * Element-wise base-2 logarithm
+ * @param x - Input array
+ * @returns Array of log2 values
+ */
+export declare function log2(x: NDArray): NDArray;
+/**
+ * Element-wise base-10 logarithm
+ * @param x - Input array
+ * @returns Array of log10 values
+ */
+export declare function log10(x: NDArray): NDArray;
+/**
+ * Element-wise natural logarithm of (1 + x)
+ * More accurate than log(1 + x) for small x
+ * @param x - Input array
+ * @returns Array of log1p values
+ */
+export declare function log1p(x: NDArray): NDArray;
+/**
+ * Logarithm of the sum of exponentials: log(exp(x1) + exp(x2))
+ * More numerically stable than computing the expression directly
+ * @param x1 - First input array
+ * @param x2 - Second input array or scalar
+ * @returns Array of logaddexp values
+ */
+export declare function logaddexp(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Logarithm base 2 of the sum of exponentials: log2(2^x1 + 2^x2)
+ * More numerically stable than computing the expression directly
+ * @param x1 - First input array
+ * @param x2 - Second input array or scalar
+ * @returns Array of logaddexp2 values
+ */
+export declare function logaddexp2(x1: NDArray, x2: NDArray | number): NDArray;
 /**
  * Element-wise absolute value
  * @param x - Input array
@@ -1904,6 +2068,108 @@ export declare function unpackbits(a: NDArray, axis?: number, count?: number, bi
  * einsum('ii->', a)
  */
 export declare function einsum(subscripts: string, ...operands: NDArray[]): NDArray | number | bigint;
+/**
+ * numpy.linalg module - Linear algebra functions
+ */
+export declare const linalg: {
+    /**
+     * Cross product of two vectors.
+     */
+    cross: (a: NDArray, b: NDArray, axisa?: number, axisb?: number, axisc?: number, axis?: number) => NDArray | number;
+    /**
+     * Compute the norm of a vector or matrix.
+     */
+    norm: (x: NDArray, ord?: number | "fro" | "nuc" | null, axis?: number | [number, number] | null, keepdims?: boolean) => NDArray | number;
+    /**
+     * Compute the vector norm.
+     */
+    vector_norm: (x: NDArray, ord?: number, axis?: number | null, keepdims?: boolean) => NDArray | number;
+    /**
+     * Compute the matrix norm.
+     */
+    matrix_norm: (x: NDArray, ord?: number | "fro" | "nuc", keepdims?: boolean) => NDArray | number;
+    /**
+     * QR decomposition.
+     */
+    qr: (a: NDArray, mode?: "reduced" | "complete" | "r" | "raw") => {
+        q: NDArray;
+        r: NDArray;
+    } | NDArray | {
+        h: NDArray;
+        tau: NDArray;
+    };
+    /**
+     * Cholesky decomposition.
+     */
+    cholesky: (a: NDArray, upper?: boolean) => NDArray;
+    /**
+     * Singular Value Decomposition.
+     */
+    svd: (a: NDArray, full_matrices?: boolean, compute_uv?: boolean) => {
+        u: NDArray;
+        s: NDArray;
+        vt: NDArray;
+    } | NDArray;
+    /**
+     * Compute the determinant of a matrix.
+     */
+    det: (a: NDArray) => number;
+    /**
+     * Compute the matrix inverse.
+     */
+    inv: (a: NDArray) => NDArray;
+    /**
+     * Solve a linear system.
+     */
+    solve: (a: NDArray, b: NDArray) => NDArray;
+    /**
+     * Least-squares solution to a linear matrix equation.
+     */
+    lstsq: (a: NDArray, b: NDArray, rcond?: number | null) => {
+        x: NDArray;
+        residuals: NDArray;
+        rank: number;
+        s: NDArray;
+    };
+    /**
+     * Compute the condition number.
+     */
+    cond: (a: NDArray, p?: number | "fro" | "nuc") => number;
+    /**
+     * Compute the matrix rank.
+     */
+    matrix_rank: (a: NDArray, tol?: number) => number;
+    /**
+     * Raise a square matrix to an integer power.
+     */
+    matrix_power: (a: NDArray, n: number) => NDArray;
+    /**
+     * Compute the Moore-Penrose pseudo-inverse.
+     */
+    pinv: (a: NDArray, rcond?: number) => NDArray;
+    /**
+     * Compute eigenvalues and eigenvectors.
+     */
+    eig: (a: NDArray) => {
+        w: NDArray;
+        v: NDArray;
+    };
+    /**
+     * Compute eigenvalues and eigenvectors of a Hermitian matrix.
+     */
+    eigh: (a: NDArray, UPLO?: "L" | "U") => {
+        w: NDArray;
+        v: NDArray;
+    };
+    /**
+     * Compute eigenvalues of a matrix.
+     */
+    eigvals: (a: NDArray) => NDArray;
+    /**
+     * Compute eigenvalues of a Hermitian matrix.
+     */
+    eigvalsh: (a: NDArray, UPLO?: "L" | "U") => NDArray;
+};
 /**
  * Take values from the input array by matching 1d index and data slices along axis.
  *
@@ -2135,4 +2401,140 @@ export declare function extract(condition: NDArray, a: NDArray): NDArray;
  * @returns Count of non-zero values
  */
 export declare function count_nonzero(a: NDArray, axis?: number): NDArray | number;
+/**
+ * Round an array to the given number of decimals
+ * @param a - Input array
+ * @param decimals - Number of decimal places to round to (default: 0)
+ * @returns Rounded array
+ */
+export declare function around(a: NDArray, decimals?: number): NDArray;
+/**
+ * Return the ceiling of the input, element-wise
+ * @param x - Input array
+ * @returns Element-wise ceiling
+ */
+export declare function ceil(x: NDArray): NDArray;
+/**
+ * Round to nearest integer towards zero
+ * @param x - Input array
+ * @returns Array with values truncated towards zero
+ */
+export declare function fix(x: NDArray): NDArray;
+/**
+ * Return the floor of the input, element-wise
+ * @param x - Input array
+ * @returns Element-wise floor
+ */
+export declare function floor(x: NDArray): NDArray;
+/**
+ * Round elements of the array to the nearest integer
+ * @param x - Input array
+ * @returns Array with rounded integer values
+ */
+export declare function rint(x: NDArray): NDArray;
+/**
+ * Evenly round to the given number of decimals (alias for around)
+ * @param a - Input array
+ * @param decimals - Number of decimal places to round to (default: 0)
+ * @returns Rounded array
+ */
+export { around as round };
+/**
+ * Return the truncated value of the input, element-wise
+ * @param x - Input array
+ * @returns Element-wise truncated values
+ */
+export declare function trunc(x: NDArray): NDArray;
+/**
+ * Find the unique elements of an array
+ * @param ar - Input array
+ * @param returnIndex - If True, also return the indices of the first occurrences
+ * @param returnInverse - If True, also return the indices to reconstruct the original array
+ * @param returnCounts - If True, also return the number of times each unique value appears
+ * @returns Unique sorted values, and optionally indices/inverse/counts
+ */
+export declare function unique(ar: NDArray, returnIndex?: boolean, returnInverse?: boolean, returnCounts?: boolean): NDArray | {
+    values: NDArray;
+    indices?: NDArray;
+    inverse?: NDArray;
+    counts?: NDArray;
+};
+/**
+ * Test whether each element of a 1-D array is also present in a second array
+ * @param ar1 - Input array
+ * @param ar2 - Test values
+ * @returns Boolean array indicating membership
+ */
+export declare function in1d(ar1: NDArray, ar2: NDArray): NDArray;
+/**
+ * Find the intersection of two arrays
+ * @param ar1 - First input array
+ * @param ar2 - Second input array
+ * @returns Sorted 1D array of common and unique elements
+ */
+export declare function intersect1d(ar1: NDArray, ar2: NDArray): NDArray;
+/**
+ * Test whether each element of an ND array is also present in a second array
+ * @param element - Input array
+ * @param testElements - Test values
+ * @returns Boolean array indicating membership (same shape as element)
+ */
+export declare function isin(element: NDArray, testElements: NDArray): NDArray;
+/**
+ * Find the set difference of two arrays
+ * @param ar1 - First input array
+ * @param ar2 - Second input array
+ * @returns Sorted 1D array of values in ar1 that are not in ar2
+ */
+export declare function setdiff1d(ar1: NDArray, ar2: NDArray): NDArray;
+/**
+ * Find the set exclusive-or of two arrays
+ * @param ar1 - First input array
+ * @param ar2 - Second input array
+ * @returns Sorted 1D array of values that are in only one array
+ */
+export declare function setxor1d(ar1: NDArray, ar2: NDArray): NDArray;
+/**
+ * Find the union of two arrays
+ * @param ar1 - First input array
+ * @param ar2 - Second input array
+ * @returns Sorted 1D array of unique values from both arrays
+ */
+export declare function union1d(ar1: NDArray, ar2: NDArray): NDArray;
+/**
+ * Calculate the n-th discrete difference along the given axis
+ * @param a - Input array
+ * @param n - Number of times values are differenced (default: 1)
+ * @param axis - Axis along which to compute difference (default: -1)
+ * @returns Array of differences
+ */
+export declare function diff(a: NDArray, n?: number, axis?: number): NDArray;
+/**
+ * The differences between consecutive elements of a flattened array
+ * @param ary - Input array
+ * @param to_end - Number(s) to append at the end
+ * @param to_begin - Number(s) to prepend at the beginning
+ * @returns Array of differences
+ */
+export declare function ediff1d(ary: NDArray, to_end?: number[] | null, to_begin?: number[] | null): NDArray;
+/**
+ * Return the gradient of an N-dimensional array
+ * The gradient is computed using second order accurate central differences
+ * in the interior and first order accurate one-sided differences at the boundaries.
+ * @param f - Input array
+ * @param varargs - Spacing between values (scalar or array per dimension)
+ * @param axis - Axis or axes along which to compute gradient
+ * @returns Array of gradients (one per axis) or single gradient
+ */
+export declare function gradient(f: NDArray, varargs?: number | number[], axis?: number | number[] | null): NDArray | NDArray[];
+/**
+ * Return the cross product of two (arrays of) vectors
+ * @param a - First input array
+ * @param b - Second input array
+ * @param axisa - Axis of a that defines the vector(s) (default: -1)
+ * @param axisb - Axis of b that defines the vector(s) (default: -1)
+ * @param axisc - Axis of c containing the cross product (default: -1)
+ * @returns Cross product array
+ */
+export declare function cross(a: NDArray, b: NDArray, axisa?: number, axisb?: number, axisc?: number): NDArray;
 //# sourceMappingURL=ndarray.d.ts.map

package/dist/types/index.d.ts

@@ -3,7 +3,7 @@
  *
  * @module numpy-ts
  */
-export { NDArray, zeros, ones, array, arange, linspace, logspace, geomspace, eye, empty, full, identity, asarray, copy, zeros_like, ones_like, empty_like, full_like, asanyarray, ascontiguousarray, asfortranarray, diag, diagflat, frombuffer, fromfile, fromfunction, fromiter, fromstring, meshgrid, tri, tril, triu, vander, sqrt, power, absolute, negative, sign, mod, floor_divide, positive, reciprocal, cbrt, fabs, divmod, square, remainder, heaviside, dot, trace, diagonal, kron, transpose, inner, outer, tensordot, einsum, sin, cos, tan, arcsin, arccos, arctan, arctan2, hypot, degrees, radians, deg2rad, rad2deg, sinh, cosh, tanh, arcsinh, arccosh, arctanh, swapaxes, moveaxis, concatenate, stack, vstack, hstack, dstack, split, array_split, vsplit, hsplit, tile, repeat, ravel, reshape, squeeze, expand_dims, flip, fliplr, flipud, rot90, roll, rollaxis, atleast_1d, atleast_2d, atleast_3d, dsplit, column_stack, row_stack, resize, append, delete_ as delete, insert, pad, broadcast_to, broadcast_arrays, broadcast_shapes, take, put, choose, array_equal, array_equiv, take_along_axis, put_along_axis, putmask, compress, select, place, diag_indices, diag_indices_from, tril_indices, tril_indices_from, triu_indices, triu_indices_from, mask_indices, indices, ix_, ravel_multi_index, unravel_index, cumsum, cumprod, ptp, median, percentile, quantile, average, nansum, nanprod, nanmean, nanvar, nanstd, nanmin, nanmax, nanargmin, nanargmax, nancumsum, nancumprod, nanmedian, bitwise_and, bitwise_or, bitwise_xor, bitwise_not, invert, left_shift, right_shift, packbits, unpackbits, sort, argsort, lexsort, partition, argpartition, sort_complex, nonzero, flatnonzero, where, searchsorted, extract, count_nonzero, } from './core/ndarray';
+export { NDArray, zeros, ones, array, arange, linspace, logspace, geomspace, eye, empty, full, identity, asarray, copy, zeros_like, ones_like, empty_like, full_like, asanyarray, ascontiguousarray, asfortranarray, diag, diagflat, frombuffer, fromfile, fromfunction, fromiter, fromstring, meshgrid, tri, tril, triu, vander, sqrt, power, exp, exp2, expm1, log, log2, log10, log1p, logaddexp, logaddexp2, absolute, negative, sign, mod, floor_divide, positive, reciprocal, cbrt, fabs, divmod, square, remainder, heaviside, dot, trace, diagonal, kron, transpose, inner, outer, tensordot, einsum, linalg, sin, cos, tan, arcsin, arccos, arctan, arctan2, hypot, degrees, radians, deg2rad, rad2deg, sinh, cosh, tanh, arcsinh, arccosh, arctanh, swapaxes, moveaxis, concatenate, stack, vstack, hstack, dstack, split, array_split, vsplit, hsplit, tile, repeat, ravel, reshape, squeeze, expand_dims, flip, fliplr, flipud, rot90, roll, rollaxis, atleast_1d, atleast_2d, atleast_3d, dsplit, column_stack, row_stack, resize, append, delete_ as delete, insert, pad, broadcast_to, broadcast_arrays, broadcast_shapes, take, put, choose, array_equal, array_equiv, take_along_axis, put_along_axis, putmask, compress, select, place, diag_indices, diag_indices_from, tril_indices, tril_indices_from, triu_indices, triu_indices_from, mask_indices, indices, ix_, ravel_multi_index, unravel_index, cumsum, cumprod, ptp, median, percentile, quantile, average, nansum, nanprod, nanmean, nanvar, nanstd, nanmin, nanmax, nanargmin, nanargmax, nancumsum, nancumprod, nanmedian, bitwise_and, bitwise_or, bitwise_xor, bitwise_not, invert, left_shift, right_shift, packbits, unpackbits, sort, argsort, lexsort, partition, argpartition, sort_complex, nonzero, flatnonzero, where, searchsorted, extract, count_nonzero, around, ceil, fix, floor, rint, round, trunc, unique, in1d, intersect1d, isin, setdiff1d, setxor1d, union1d, diff, ediff1d, gradient, cross, } from './core/ndarray';
 export { parseNpy, serializeNpy, parseNpyHeader, parseNpyData, UnsupportedDTypeError, InvalidNpyError, SUPPORTED_DTYPES, DTYPE_TO_DESCR, type NpyHeader, type NpyMetadata, type NpyVersion, parseNpz, parseNpzSync, loadNpz, loadNpzSync, serializeNpz, serializeNpzSync, type NpzParseOptions, type NpzParseResult, type NpzSerializeOptions, } from './io';
 export declare const __version__: string;
 //# sourceMappingURL=index.d.ts.map

package/dist/types/ops/exponential.d.ts

@@ -2,7 +2,7 @@
  * Exponential, logarithmic, and power operations
  *
  * Pure functions for element-wise exponential operations:
- * exp, log, sqrt, power, etc.
+ * exp, exp2, expm1, log, log2, log10, log1p, logaddexp, logaddexp2, sqrt, power
  *
  * These functions are used by NDArray methods but are separated
  * to keep the codebase modular and testable.
@@ -25,4 +25,82 @@ export declare function sqrt(a: ArrayStorage): ArrayStorage;
  * @returns Result storage with power applied
  */
 export declare function power(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Natural exponential function (e^x) for each element
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage
+ * @returns Result storage with exp applied
+ */
+export declare function exp(a: ArrayStorage): ArrayStorage;
+/**
+ * Base-2 exponential function (2^x) for each element
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage
+ * @returns Result storage with 2^x applied
+ */
+export declare function exp2(a: ArrayStorage): ArrayStorage;
+/**
+ * Exponential minus one (e^x - 1) for each element
+ * More accurate than exp(x) - 1 for small x
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage
+ * @returns Result storage with expm1 applied
+ */
+export declare function expm1(a: ArrayStorage): ArrayStorage;
+/**
+ * Natural logarithm (ln) for each element
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage
+ * @returns Result storage with log applied
+ */
+export declare function log(a: ArrayStorage): ArrayStorage;
+/**
+ * Base-2 logarithm for each element
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage
+ * @returns Result storage with log2 applied
+ */
+export declare function log2(a: ArrayStorage): ArrayStorage;
+/**
+ * Base-10 logarithm for each element
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage
+ * @returns Result storage with log10 applied
+ */
+export declare function log10(a: ArrayStorage): ArrayStorage;
+/**
+ * Natural logarithm of (1 + x) for each element
+ * More accurate than log(1 + x) for small x
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage
+ * @returns Result storage with log1p applied
+ */
+export declare function log1p(a: ArrayStorage): ArrayStorage;
+/**
+ * Logarithm of the sum of exponentials: log(exp(x1) + exp(x2))
+ * More numerically stable than computing the expression directly
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param x1 - First input array storage
+ * @param x2 - Second input array storage (or scalar)
+ * @returns Result storage with logaddexp applied
+ */
+export declare function logaddexp(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Logarithm base 2 of the sum of exponentials: log2(2^x1 + 2^x2)
+ * More numerically stable than computing the expression directly
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param x1 - First input array storage
+ * @param x2 - Second input array storage (or scalar)
+ * @returns Result storage with logaddexp2 applied
+ */
+export declare function logaddexp2(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
 //# sourceMappingURL=exponential.d.ts.map

package/dist/types/ops/gradient.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Gradient and difference operations
+ *
+ * Pure functions for computing gradients and differences:
+ * gradient, diff, ediff1d, cross
+ *
+ * These functions are used by NDArray methods but are separated
+ * to keep the codebase modular and testable.
+ */
+import { ArrayStorage } from '../core/storage';
+/**
+ * Calculate the n-th discrete difference along the given axis.
+ *
+ * The first difference is given by out[i] = a[i+1] - a[i] along the given axis.
+ * Higher differences are calculated by using diff recursively.
+ *
+ * @param a - Input array storage
+ * @param n - Number of times values are differenced (default: 1)
+ * @param axis - Axis along which to compute difference (default: -1, last axis)
+ * @returns Result storage with differences
+ */
+export declare function diff(a: ArrayStorage, n?: number, axis?: number): ArrayStorage;
+/**
+ * The differences between consecutive elements of a flattened array.
+ *
+ * @param ary - Input array storage
+ * @param to_end - Number(s) to append at the end of the returned differences
+ * @param to_begin - Number(s) to prepend at the beginning of the returned differences
+ * @returns Array of differences with optional prepend/append values
+ */
+export declare function ediff1d(ary: ArrayStorage, to_end?: number[] | null, to_begin?: number[] | null): ArrayStorage;
+/**
+ * Return the gradient of an N-dimensional array.
+ *
+ * The gradient is computed using second order accurate central differences in the interior
+ * and first order accurate one-sided (forward or backwards) differences at the boundaries.
+ *
+ * @param f - Input array storage
+ * @param varargs - Spacing between values (scalar or array per dimension)
+ * @param axis - Axis or axes along which to compute gradient (default: all axes)
+ * @returns Array of gradients (one per axis) or single gradient if one axis
+ */
+export declare function gradient(f: ArrayStorage, varargs?: number | number[], axis?: number | number[] | null): ArrayStorage | ArrayStorage[];
+/**
+ * Return the cross product of two (arrays of) vectors.
+ *
+ * The cross product of a and b in R^3 is a vector perpendicular to both a and b.
+ *
+ * @param a - First input array (components of first vector(s))
+ * @param b - Second input array (components of second vector(s))
+ * @param axisa - Axis of a that defines the vector(s) (default: -1)
+ * @param axisb - Axis of b that defines the vector(s) (default: -1)
+ * @param axisc - Axis of c containing the cross product vector(s) (default: -1)
+ * @returns Cross product array
+ */
+export declare function cross(a: ArrayStorage, b: ArrayStorage, axisa?: number, axisb?: number, _axisc?: number): ArrayStorage;
+//# sourceMappingURL=gradient.d.ts.map