deepbox 0.1.0

package/dist/index-eJgeni9c.d.cts

@@ -0,0 +1,1911 @@
+import { D as DType, a as Device, S as Shape, b as TypedArray, A as Axis, T as TensorLike } from './tensor-B96jjJLQ.cjs';
+import { G as GradTensor, a as GradTensorOptions, S as SliceRange, d as dropout, g as gather, i as im2col$1, l as logSoftmax$1, n as noGrad, p as parameter, s as slice, b as softmax$1, v as variance$1 } from './index-B_DK4FKY.cjs';
+import { T as Tensor, a as TensorOptions } from './Tensor-BQLk1ltW.cjs';
+import { C as CSRMatrix, a as CSRMatrixInit } from './CSRMatrix-CwGwQRea.cjs';
+
+/**
+ * Recursive type for nested number arrays.
+ *
+ * Used to represent multi-dimensional data in JavaScript arrays.
+ *
+ * @example
+ * ```ts
+ * const scalar: NestedArray = 5;
+ * const vector: NestedArray = [1, 2, 3];
+ * const matrix: NestedArray = [[1, 2], [3, 4]];
+ * const tensor3d: NestedArray = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]];
+ * ```
+ */
+type NestedArray = number | NestedArray[];
+type StringNestedArray = string | StringNestedArray[];
+type TensorCreateOptions = {
+    readonly dtype?: DType;
+    readonly device?: Device;
+};
+/**
+ * Create a tensor from nested arrays or TypedArray.
+ *
+ * This is the primary function for creating tensors. It accepts:
+ * - Nested JavaScript arrays (e.g., [[1, 2], [3, 4]])
+ * - TypedArrays (e.g., Float32Array)
+ * - Scalars (single numbers)
+ *
+ * Time complexity: O(n) where n is total number of elements.
+ * Space complexity: O(n) for data storage.
+ *
+ * @param data - Input data as nested array or TypedArray
+ * @param opts - Creation options (dtype, device)
+ * @returns New tensor
+ *
+ * @throws {TypeError} If data has inconsistent shape (ragged arrays)
+ * @throws {DTypeError} If dtype is incompatible with data
+ *
+ * @example
+ * ```ts
+ * import { tensor } from 'deepbox/ndarray';
+ *
+ * // From nested arrays
+ * const t1 = tensor([[1, 2, 3], [4, 5, 6]]);
+ *
+ * // Specify dtype
+ * const t2 = tensor([1, 2, 3], { dtype: 'int32' });
+ *
+ * // From TypedArray
+ * const data = new Float32Array([1, 2, 3, 4]);
+ * const t3 = tensor(data);
+ *
+ * // Scalar
+ * const t4 = tensor(42);
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.array.html | NumPy array}
+ */
+declare function tensor(data: NestedArray | StringNestedArray | TypedArray, opts?: TensorCreateOptions): Tensor;
+/**
+ * All zeros.
+ */
+declare function zeros(shape: Shape, opts?: TensorCreateOptions): Tensor;
+/**
+ * All ones.
+ */
+declare function ones(shape: Shape, opts?: TensorCreateOptions): Tensor;
+/**
+ * Fill with a scalar value.
+ */
+declare function empty(shape: Shape, opts?: TensorCreateOptions): Tensor;
+declare function full(shape: Shape, value: number | string, opts?: TensorCreateOptions): Tensor;
+/**
+ * Range.
+ */
+declare function arange(start: number, stop?: number, step?: number, opts?: TensorCreateOptions): Tensor;
+/**
+ * Evenly spaced numbers over a specified interval.
+ *
+ * Returns `num` evenly spaced samples, calculated over the interval [start, stop].
+ *
+ * **Algorithm**: Linear interpolation
+ *
+ * **Parameters**:
+ * @param start - Starting value of the sequence
+ * @param stop - End value of the sequence
+ * @param num - Number of samples to generate (default: 50)
+ * @param endpoint - If true, stop is the last sample. Otherwise, it is not included (default: true)
+ * @param opts - Tensor options (dtype, device)
+ *
+ * **Returns**: Tensor of shape (num,)
+ *
+ * @example
+ * ```ts
+ * import { linspace } from 'deepbox/ndarray';
+ *
+ * const x = linspace(0, 10, 5);
+ * // [0, 2.5, 5, 7.5, 10]
+ *
+ * const y = linspace(0, 10, 5, false);
+ * // [0, 2, 4, 6, 8]
+ * ```
+ *
+ * @throws {RangeError} If num < 0
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.linspace.html | NumPy linspace}
+ */
+declare function linspace(start: number, stop: number, num?: number, endpoint?: boolean, opts?: TensorCreateOptions): Tensor;
+/**
+ * Numbers spaced evenly on a log scale.
+ *
+ * In linear space, the sequence starts at base^start and ends with base^stop.
+ *
+ * **Parameters**:
+ * @param start - base^start is the starting value
+ * @param stop - base^stop is the final value
+ * @param num - Number of samples to generate (default: 50)
+ * @param base - The base of the log space (default: 10)
+ * @param endpoint - If true, stop is the last sample (default: true)
+ * @param opts - Tensor options
+ *
+ * **Returns**: Tensor of shape (num,)
+ *
+ * @example
+ * ```ts
+ * import { logspace } from 'deepbox/ndarray';
+ *
+ * const x = logspace(0, 3, 4);
+ * // [1, 10, 100, 1000]
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.logspace.html | NumPy logspace}
+ */
+declare function logspace(start: number, stop: number, num?: number, base?: number, endpoint?: boolean, opts?: TensorCreateOptions): Tensor;
+/**
+ * Numbers spaced evenly on a log scale (geometric progression).
+ *
+ * Each output value is a constant multiple of the previous.
+ *
+ * **Parameters**:
+ * @param start - Starting value of the sequence
+ * @param stop - Final value of the sequence
+ * @param num - Number of samples (default: 50)
+ * @param endpoint - If true, stop is the last sample (default: true)
+ * @param opts - Tensor options
+ *
+ * **Returns**: Tensor of shape (num,)
+ *
+ * @example
+ * ```ts
+ * import { geomspace } from 'deepbox/ndarray';
+ *
+ * const x = geomspace(1, 1000, 4);
+ * // [1, 10, 100, 1000]
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.geomspace.html | NumPy geomspace}
+ */
+declare function geomspace(start: number, stop: number, num?: number, endpoint?: boolean, opts?: TensorCreateOptions): Tensor;
+/**
+ * Identity matrix.
+ *
+ * Returns a 2D tensor with ones on the diagonal and zeros elsewhere.
+ *
+ * **Parameters**:
+ * @param n - Number of rows
+ * @param m - Number of columns (default: n, making it square)
+ * @param k - Index of the diagonal (default: 0, main diagonal)
+ * @param opts - Tensor options
+ *
+ * **Returns**: Tensor of shape (n, m)
+ *
+ * @example
+ * ```ts
+ * import { eye } from 'deepbox/ndarray';
+ *
+ * const I = eye(3);
+ * // [[1, 0, 0],
+ * //  [0, 1, 0],
+ * //  [0, 0, 1]]
+ *
+ * const A = eye(3, 4, 1);
+ * // [[0, 1, 0, 0],
+ * //  [0, 0, 1, 0],
+ * //  [0, 0, 0, 1]]
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.eye.html | NumPy eye}
+ */
+declare function eye(n: number, m?: number, k?: number, opts?: TensorCreateOptions): Tensor;
+/**
+ * Return a tensor filled with random samples from a standard normal distribution.
+ *
+ * @param shape - Shape of the output tensor
+ * @param opts - Additional tensor options
+ *
+ * @example
+ * ```ts
+ * import { randn } from 'deepbox/ndarray';
+ *
+ * const x = randn([2, 3]);
+ * // Random values from N(0, 1)
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/random/generated/numpy.random.randn.html | NumPy randn}
+ */
+declare function randn(shape: Shape, opts?: TensorCreateOptions): Tensor;
+
+/**
+ * Change shape (view) without copying.
+ *
+ * Notes:
+ * - Currently only supports contiguous tensors.
+ * - In the future, reshape should support more view cases using strides.
+ */
+declare function reshape(t: Tensor, newShape: Shape): Tensor;
+/**
+ * Flatten to 1D.
+ */
+declare function flatten(t: Tensor): Tensor;
+/**
+ * Transpose tensor dimensions.
+ *
+ * Reverses or permutes the axes of a tensor.
+ *
+ * @param t - Input tensor
+ * @param axes - Permutation of axes. If undefined, reverses all axes
+ * @returns Transposed tensor
+ *
+ * @example
+ * ```ts
+ * import { transpose, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([[1, 2], [3, 4]]);  // shape: (2, 2)
+ * const y = transpose(x);              // shape: (2, 2), values: [[1, 3], [2, 4]]
+ *
+ * const z = tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]);  // shape: (2, 2, 2)
+ * const w = transpose(z, [2, 0, 1]);   // shape: (2, 2, 2), axes permuted
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.transpose.html | NumPy transpose}
+ */
+declare function transpose(t: Tensor, axes?: readonly number[]): Tensor;
+
+/**
+ * Compute dot product or matrix multiplication.
+ *
+ * Supported cases:
+ * - Both 1-D (vector, vector): inner product, returns a scalar tensor
+ * - Both 2-D (matrix, matrix): standard matrix multiplication (m,k) x (k,n) -> (m,n)
+ * - 2-D x 1-D (matrix, vector): matrix-vector product (m,k) x (k,) -> (m,)
+ * - Both 3-D: batch matrix multiplication (b,m,k) x (b,k,n) -> (b,m,n)
+ *
+ * Other combinations (e.g., 1-D x 2-D, mixed dimensionalities above 3-D)
+ * are not yet implemented and will throw a ShapeError.
+ *
+ * @param a - First tensor
+ * @param b - Second tensor
+ * @returns Dot product result
+ */
+declare function dot(a: Tensor, b: Tensor): Tensor;
+
+/**
+ * Sigmoid activation function.
+ *
+ * Applies element-wise: sigmoid(x) = 1 / (1 + exp(-x))
+ *
+ * **Properties**:
+ * - Output range: (0, 1)
+ * - Smooth gradient
+ * - Can suffer from vanishing gradients
+ *
+ * @example
+ * ```ts
+ * import { sigmoid, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([-1, 0, 1]);
+ * const result = sigmoid(x);  // [0.268..., 0.5, 0.731...]
+ * ```
+ *
+ * @see {@link https://en.wikipedia.org/wiki/Sigmoid_function | Wikipedia: Sigmoid}
+ */
+declare function sigmoid(t: Tensor): Tensor;
+/**
+ * Rectified Linear Unit activation.
+ *
+ * Applies element-wise: relu(x) = max(0, x)
+ *
+ * **Properties**:
+ * - Output range: [0, ∞)
+ * - Non-linear but simple
+ * - Can suffer from dying ReLU problem
+ *
+ * @example
+ * ```ts
+ * import { relu, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([-1, 0, 1]);
+ * const result = relu(x);  // [0, 0, 1]
+ * ```
+ *
+ * @see {@link https://en.wikipedia.org/wiki/Rectifier_(neural_networks) | Wikipedia: ReLU}
+ */
+declare function relu(t: Tensor): Tensor;
+/**
+ * Leaky ReLU activation.
+ *
+ * Applies element-wise: leaky_relu(x) = max(alpha * x, x)
+ *
+ * **Parameters**:
+ * @param t - Input tensor
+ * @param alpha - Slope for negative values (default: 0.01)
+ *
+ * @example
+ * ```ts
+ * import { leakyRelu, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([-1, 0, 1]);
+ * const result = leakyRelu(x, 0.1);  // [-0.1, 0, 1]
+ * ```
+ */
+declare function leakyRelu(t: Tensor, alpha?: number): Tensor;
+/**
+ * Exponential Linear Unit activation.
+ *
+ * Applies element-wise:
+ * - elu(x) = x if x > 0
+ * - elu(x) = alpha * (exp(x) - 1) if x <= 0
+ *
+ * **Parameters**:
+ * @param t - Input tensor
+ * @param alpha - Scale for negative values (default: 1.0)
+ *
+ * @example
+ * ```ts
+ * import { elu, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([-1, 0, 1]);
+ * const result = elu(x);
+ * ```
+ */
+declare function elu(t: Tensor, alpha?: number): Tensor;
+/**
+ * Gaussian Error Linear Unit activation.
+ *
+ * Applies element-wise: gelu(x) = x * Φ(x)
+ * where Φ(x) is the cumulative distribution function of the standard normal distribution.
+ *
+ * **Algorithm**: Can use tanh approximation or erf function
+ *
+ * @example
+ * ```ts
+ * import { gelu, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([-1, 0, 1]);
+ * const result = gelu(x);
+ * ```
+ *
+ * @see Hendrycks & Gimpel (2016) "Gaussian Error Linear Units (GELUs)"
+ */
+declare function gelu(t: Tensor): Tensor;
+/**
+ * Softmax activation function.
+ *
+ * Normalizes input to probability distribution over classes.
+ * Applies along specified axis: softmax(x)_i = exp(x_i - max(x)) / sum(exp(x - max(x)))
+ *
+ * Uses numerically stable computation by subtracting the maximum value
+ * along the axis before exponentiating.
+ *
+ * **Parameters**:
+ * @param t - Input tensor of any dimensionality
+ * @param axis - Axis along which to compute softmax (default: -1, i.e., last axis)
+ *
+ * **Properties**:
+ * - Output sums to 1 along the specified axis
+ * - Output values in (0, 1)
+ * - Supports tensors of any dimensionality
+ *
+ * Output dtype:
+ * - `float64`
+ *
+ * @example
+ * ```ts
+ * import { softmax, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([[1, 2, 3], [1, 2, 3]]);
+ * const result = softmax(x, 1);  // Each row sums to 1
+ *
+ * const x3d = tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]);
+ * const result3d = softmax(x3d, -1);  // Softmax along last axis
+ * ```
+ *
+ * @see {@link https://en.wikipedia.org/wiki/Softmax_function | Wikipedia: Softmax}
+ */
+declare function softmax(t: Tensor, axis?: Axis): Tensor;
+/**
+ * Log-Softmax activation function.
+ *
+ * Computes log(softmax(x)) in a numerically stable way.
+ * Uses the identity: log_softmax(x) = x - max(x) - log(sum(exp(x - max(x))))
+ *
+ * **Parameters**:
+ * @param t - Input tensor of any dimensionality
+ * @param axis - Axis along which to compute log-softmax (default: -1, i.e., last axis)
+ *
+ * **Properties**:
+ * - More numerically stable than computing log(softmax(x)) directly
+ * - Output values are log probabilities (negative values, sum to 0 when exp'd)
+ * - Supports tensors of any dimensionality
+ *
+ * Output dtype:
+ * - `float64`
+ *
+ * **Performance**:
+ * - Time complexity: O(n) where n is the tensor size
+ * - Space complexity: O(axisSize) for temporary buffer (reused across slices)
+ * - More efficient than computing log(softmax(x)) separately
+ *
+ * @example
+ * ```ts
+ * import { logSoftmax, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([[1, 2, 3]]);
+ * const result = logSoftmax(x, 1);
+ *
+ * const x3d = tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]);
+ * const result3d = logSoftmax(x3d, -1);  // Log-softmax along last axis
+ * ```
+ */
+declare function logSoftmax(t: Tensor, axis?: Axis): Tensor;
+/**
+ * Swish activation function (also known as SiLU).
+ *
+ * Applies element-wise: swish(x) = x * sigmoid(x)
+ *
+ * @example
+ * ```ts
+ * import { swish, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([-1, 0, 1]);
+ * const result = swish(x);
+ * ```
+ *
+ * @see Ramachandran et al. (2017) "Searching for Activation Functions"
+ */
+declare function swish(t: Tensor): Tensor;
+/**
+ * Mish activation function.
+ *
+ * Applies element-wise: mish(x) = x * tanh(softplus(x))
+ * where softplus(x) = log(1 + exp(x))
+ *
+ * @example
+ * ```ts
+ * import { mish, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([-1, 0, 1]);
+ * const result = mish(x);
+ * ```
+ *
+ * @see Misra (2019) "Mish: A Self Regularized Non-Monotonic Activation Function"
+ */
+declare function mish(t: Tensor): Tensor;
+/**
+ * Softplus activation function.
+ *
+ * Smooth approximation of ReLU: softplus(x) = log(1 + exp(x))
+ *
+ * @example
+ * ```ts
+ * import { softplus, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([-1, 0, 1]);
+ * const result = softplus(x);
+ * ```
+ */
+declare function softplus(t: Tensor): Tensor;
+
+/**
+ * Image to Column operation (im2col).
+ *
+ * Rearranges image blocks into columns.
+ *
+ * @param input - Input tensor of shape (batch, channels, height, width)
+ * @param kernelSize - Size of the kernel [kH, kW]
+ * @param stride - Stride [sH, sW]
+ * @param padding - Padding [pH, pW]
+ * @returns Output tensor of shape (batch, outH * outW, channels * kH * kW)
+ */
+declare function im2col(input: Tensor, kernelSize: [number, number], stride: [number, number], padding: [number, number]): Tensor;
+/**
+ * Column to Image operation (col2im).
+ *
+ * Rearranges columns back into image blocks (accumulating values).
+ * Used for gradient computation.
+ *
+ * @param cols - Column tensor of shape (batch, outH * outW, channels * kH * kW)
+ * @param inputShape - Shape of the original image (batch, channels, height, width)
+ * @param kernelSize - Size of the kernel [kH, kW]
+ * @param stride - Stride [sH, sW]
+ * @param padding - Padding [pH, pW]
+ * @returns Gradient tensor of shape inputShape
+ */
+declare function col2im(cols: Tensor, inputShape: Shape, kernelSize: [number, number], stride: [number, number], padding: [number, number]): Tensor;
+
+/**
+ * Element-wise addition.
+ *
+ * Supported:
+ * - Standard broadcasting semantics (including scalar and dimension-1 broadcast)
+ */
+declare function add(a: Tensor, b: Tensor): Tensor;
+/**
+ * Element-wise subtraction.
+ *
+ * Computes a - b element by element.
+ *
+ * Broadcasting: supports standard numpy-style broadcasting.
+ *
+ * @param a - First tensor
+ * @param b - Second tensor
+ * @returns Tensor containing element-wise difference
+ *
+ * @example
+ * ```ts
+ * import { sub, tensor } from 'deepbox/ndarray';
+ *
+ * const a = tensor([5, 6, 7]);
+ * const b = tensor([1, 2, 3]);
+ * const result = sub(a, b);  // [4, 4, 4]
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.subtract.html | NumPy subtract}
+ */
+declare function sub(a: Tensor, b: Tensor): Tensor;
+/**
+ * Element-wise multiplication.
+ *
+ * Computes a * b element by element.
+ *
+ * Broadcasting: supports standard numpy-style broadcasting.
+ *
+ * @param a - First tensor
+ * @param b - Second tensor
+ * @returns Tensor containing element-wise product
+ *
+ * @example
+ * ```ts
+ * import { mul, tensor } from 'deepbox/ndarray';
+ *
+ * const a = tensor([2, 3, 4]);
+ * const b = tensor([5, 6, 7]);
+ * const result = mul(a, b);  // [10, 18, 28]
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.multiply.html | NumPy multiply}
+ */
+declare function mul(a: Tensor, b: Tensor): Tensor;
+/**
+ * Element-wise division.
+ *
+ * Computes a / b element by element.
+ *
+ * Broadcasting: supports standard numpy-style broadcasting.
+ *
+ * @param a - Numerator tensor
+ * @param b - Denominator tensor
+ * @returns Tensor containing element-wise quotient
+ *
+ * @example
+ * ```ts
+ * import { div, tensor } from 'deepbox/ndarray';
+ *
+ * const a = tensor([10, 20, 30]);
+ * const b = tensor([2, 4, 5]);
+ * const result = div(a, b);  // [5, 5, 6]
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.divide.html | NumPy divide}
+ */
+declare function div(a: Tensor, b: Tensor): Tensor;
+/**
+ * Add a scalar value to all elements of a tensor.
+ *
+ * @param t - Input tensor
+ * @param s - Scalar value to add
+ * @returns New tensor with scalar added to all elements
+ *
+ * @example
+ * ```ts
+ * import { addScalar, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([1, 2, 3]);
+ * const result = addScalar(x, 10);  // [11, 12, 13]
+ * ```
+ */
+declare function addScalar(t: Tensor, s: number): Tensor;
+/**
+ * Multiply all elements of a tensor by a scalar value.
+ *
+ * @param t - Input tensor
+ * @param s - Scalar multiplier
+ * @returns New tensor with all elements multiplied by scalar
+ *
+ * @example
+ * ```ts
+ * import { mulScalar, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([1, 2, 3]);
+ * const result = mulScalar(x, 10);  // [10, 20, 30]
+ * ```
+ */
+declare function mulScalar(t: Tensor, s: number): Tensor;
+/**
+ * Element-wise floor division.
+ *
+ * Computes the largest integer less than or equal to the quotient.
+ *
+ * @example
+ * ```ts
+ * import { floorDiv, tensor } from 'deepbox/ndarray';
+ *
+ * const a = tensor([7, 8, 9]);
+ * const b = tensor([3, 3, 3]);
+ * const result = floorDiv(a, b);  // [2, 2, 3]
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.floor_divide.html | NumPy floor_divide}
+ */
+declare function floorDiv(a: Tensor, b: Tensor): Tensor;
+/**
+ * Element-wise modulo operation.
+ *
+ * Returns remainder of division.
+ *
+ * @example
+ * ```ts
+ * import { mod, tensor } from 'deepbox/ndarray';
+ *
+ * const a = tensor([7, 8, 9]);
+ * const b = tensor([3, 3, 3]);
+ * const result = mod(a, b);  // [1, 2, 0]
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.mod.html | NumPy mod}
+ */
+declare function mod(a: Tensor, b: Tensor): Tensor;
+/**
+ * Element-wise power.
+ *
+ * Raises elements of first tensor to powers from second tensor.
+ *
+ * @example
+ * ```ts
+ * import { pow, tensor } from 'deepbox/ndarray';
+ *
+ * const a = tensor([2, 3, 4]);
+ * const b = tensor([2, 3, 2]);
+ * const result = pow(a, b);  // [4, 27, 16]
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.power.html | NumPy power}
+ */
+declare function pow(a: Tensor, b: Tensor): Tensor;
+/**
+ * Element-wise negation.
+ *
+ * Returns -x for each element.
+ *
+ * @example
+ * ```ts
+ * import { neg, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([1, -2, 3]);
+ * const result = neg(x);  // [-1, 2, -3]
+ * ```
+ */
+declare function neg(t: Tensor): Tensor;
+/**
+ * Element-wise absolute value.
+ *
+ * Returns |x| for each element.
+ *
+ * @example
+ * ```ts
+ * import { abs, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([-1, 2, -3]);
+ * const result = abs(x);  // [1, 2, 3]
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.absolute.html | NumPy absolute}
+ */
+declare function abs(t: Tensor): Tensor;
+/**
+ * Element-wise sign function.
+ *
+ * Returns -1, 0, or 1 depending on sign of each element.
+ *
+ * @example
+ * ```ts
+ * import { sign, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([-5, 0, 3]);
+ * const result = sign(x);  // [-1, 0, 1]
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.sign.html | NumPy sign}
+ */
+declare function sign(t: Tensor): Tensor;
+/**
+ * Element-wise reciprocal.
+ *
+ * Returns 1/x for each element.
+ *
+ * @example
+ * ```ts
+ * import { reciprocal, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([2, 4, 8]);
+ * const result = reciprocal(x);  // [0.5, 0.25, 0.125]
+ * ```
+ */
+declare function reciprocal(t: Tensor): Tensor;
+/**
+ * Element-wise maximum of two tensors.
+ *
+ * @example
+ * ```ts
+ * import { maximum, tensor } from 'deepbox/ndarray';
+ *
+ * const a = tensor([1, 5, 3]);
+ * const b = tensor([4, 2, 6]);
+ * const result = maximum(a, b);  // [4, 5, 6]
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.maximum.html | NumPy maximum}
+ */
+declare function maximum(a: Tensor, b: Tensor): Tensor;
+/**
+ * Element-wise minimum of two tensors.
+ *
+ * @example
+ * ```ts
+ * import { minimum, tensor } from 'deepbox/ndarray';
+ *
+ * const a = tensor([1, 5, 3]);
+ * const b = tensor([4, 2, 6]);
+ * const result = minimum(a, b);  // [1, 2, 3]
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.minimum.html | NumPy minimum}
+ */
+declare function minimum(a: Tensor, b: Tensor): Tensor;
+/**
+ * Clip (limit) values in tensor.
+ *
+ * Given an interval, values outside the interval are clipped to interval edges.
+ *
+ * **Parameters**:
+ * @param t - Input tensor
+ * @param min - Minimum value. If undefined, no lower clipping
+ * @param max - Maximum value. If undefined, no upper clipping
+ *
+ * @example
+ * ```ts
+ * import { clip, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([1, 2, 3, 4, 5]);
+ * const result = clip(x, 2, 4);  // [2, 2, 3, 4, 4]
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.clip.html | NumPy clip}
+ */
+declare function clip(t: Tensor, min?: number, max?: number): Tensor;
+
+/**
+ * Element-wise equality.
+ *
+ * Output dtype:
+ * - `bool`
+ */
+declare function equal(a: Tensor, b: Tensor): Tensor;
+/**
+ * Element-wise inequality (not equal) comparison.
+ *
+ * Returns a boolean tensor where each element is true (1) if the
+ * corresponding elements in a and b are not equal, false (0) otherwise.
+ *
+ * @param a - First input tensor
+ * @param b - Second input tensor
+ * @returns Boolean tensor of same shape as inputs
+ */
+declare function notEqual(a: Tensor, b: Tensor): Tensor;
+/**
+ * Element-wise greater than comparison (a > b).
+ *
+ * Returns a boolean tensor where each element is true (1) if the
+ * corresponding element in a is greater than the element in b.
+ *
+ * @param a - First input tensor
+ * @param b - Second input tensor
+ * @returns Boolean tensor with comparison results
+ */
+declare function greater(a: Tensor, b: Tensor): Tensor;
+/**
+ * Element-wise greater than or equal comparison (a >= b).
+ *
+ * @param a - First input tensor
+ * @param b - Second input tensor
+ * @returns Boolean tensor with comparison results
+ */
+declare function greaterEqual(a: Tensor, b: Tensor): Tensor;
+/**
+ * Element-wise less than comparison (a < b).
+ *
+ * @param a - First input tensor
+ * @param b - Second input tensor
+ * @returns Boolean tensor with comparison results
+ */
+declare function less(a: Tensor, b: Tensor): Tensor;
+/**
+ * Element-wise less than or equal comparison (a <= b).
+ *
+ * @param a - First input tensor
+ * @param b - Second input tensor
+ * @returns Boolean tensor with comparison results
+ */
+declare function lessEqual(a: Tensor, b: Tensor): Tensor;
+/**
+ * Element-wise test for approximate equality within tolerance.
+ *
+ * Returns true where: |a - b| <= (atol + rtol * |b|)
+ *
+ * Useful for floating-point comparisons where exact equality is unreliable.
+ *
+ * @param a - First input tensor
+ * @param b - Second input tensor
+ * @param rtol - Relative tolerance (default: 1e-5)
+ * @param atol - Absolute tolerance (default: 1e-8)
+ * @returns Boolean tensor with closeness test results
+ */
+declare function isclose(a: Tensor, b: Tensor, rtol?: number, atol?: number): Tensor;
+/**
+ * Test whether all corresponding elements are close within tolerance.
+ *
+ * Returns a single boolean (not a tensor) indicating if ALL elements pass
+ * the closeness test.
+ *
+ * @param a - First input tensor
+ * @param b - Second input tensor
+ * @param rtol - Relative tolerance (default: 1e-5)
+ * @param atol - Absolute tolerance (default: 1e-8)
+ * @returns True if all elements are close, false otherwise
+ */
+declare function allclose(a: Tensor, b: Tensor, rtol?: number, atol?: number): boolean;
+/**
+ * Test for exact array equality (shape, dtype, and all values).
+ *
+ * Returns a single boolean indicating if tensors are identical.
+ *
+ * @param a - First input tensor
+ * @param b - Second input tensor
+ * @returns True if arrays are exactly equal, false otherwise
+ */
+declare function arrayEqual(a: Tensor, b: Tensor): boolean;
+/**
+ * Element-wise test for NaN (Not a Number) values.
+ *
+ * Returns true (1) for NaN elements, false (0) otherwise.
+ *
+ * @param t - Input tensor
+ * @returns Boolean tensor with NaN test results
+ */
+declare function isnan(t: Tensor): Tensor;
+/**
+ * Element-wise test for infinity (+Inf or -Inf).
+ *
+ * Returns true (1) for infinite elements, false (0) otherwise.
+ * Note: NaN is NOT considered infinite.
+ *
+ * @param t - Input tensor
+ * @returns Boolean tensor with infinity test results
+ */
+declare function isinf(t: Tensor): Tensor;
+/**
+ * Element-wise test for finite values (not NaN, not Inf).
+ *
+ * Returns true (1) for finite elements, false (0) for NaN or Inf.
+ *
+ * @param t - Input tensor
+ * @returns Boolean tensor with finite test results
+ */
+declare function isfinite(t: Tensor): Tensor;
+
+/**
+ * Element-wise logical AND.
+ *
+ * Returns true (1) where both inputs are non-zero (truthy), false (0) otherwise.
+ *
+ * @param a - First input tensor
+ * @param b - Second input tensor
+ * @returns Boolean tensor with AND results
+ *
+ * @example
+ * ```ts
+ * const a = tensor([1, 0, 1]);
+ * const b = tensor([1, 1, 0]);
+ * logicalAnd(a, b);  // tensor([1, 0, 0])
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.logical_and.html | NumPy logical_and}
+ */
+declare function logicalAnd(a: Tensor, b: Tensor): Tensor;
+/**
+ * Element-wise logical OR.
+ *
+ * Returns true (1) where at least one input is non-zero (truthy).
+ *
+ * @param a - First input tensor
+ * @param b - Second input tensor
+ * @returns Boolean tensor with OR results
+ *
+ * @example
+ * ```ts
+ * const a = tensor([1, 0, 0]);
+ * const b = tensor([1, 1, 0]);
+ * logicalOr(a, b);  // tensor([1, 1, 0])
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.logical_or.html | NumPy logical_or}
+ */
+declare function logicalOr(a: Tensor, b: Tensor): Tensor;
+/**
+ * Element-wise logical XOR (exclusive OR).
+ *
+ * Returns true (1) where exactly one input is non-zero (true but not both).
+ *
+ * @param a - First input tensor
+ * @param b - Second input tensor
+ * @returns Boolean tensor with XOR results
+ *
+ * @example
+ * ```ts
+ * const a = tensor([1, 0, 1, 0]);
+ * const b = tensor([1, 1, 0, 0]);
+ * logicalXor(a, b);  // tensor([0, 1, 1, 0])
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.logical_xor.html | NumPy logical_xor}
+ */
+declare function logicalXor(a: Tensor, b: Tensor): Tensor;
+/**
+ * Element-wise logical NOT.
+ *
+ * Returns true (1) for zero elements, false (0) for non-zero elements.
+ * Inverts the truthiness of each element.
+ *
+ * @param t - Input tensor
+ * @returns Boolean tensor with NOT results
+ *
+ * @example
+ * ```ts
+ * const t = tensor([1, 0, 5, 0]);
+ * logicalNot(t);  // tensor([0, 1, 0, 1])
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.logical_not.html | NumPy logical_not}
+ */
+declare function logicalNot(t: Tensor): Tensor;
+
+/**
+ * Tensor manipulation operations.
+ *
+ * This module provides functions for manipulating tensor structure and content:
+ * - concatenate: Join tensors along an axis
+ * - stack: Stack tensors along a new axis
+ * - split: Split tensor into multiple sub-tensors
+ * - tile: Repeat tensor along axes
+ * - repeat: Repeat elements along an axis
+ * - pad: Add padding to tensor
+ * - flip: Reverse tensor along axes
+ *
+ * All operations maintain type safety and proper error handling.
+ */
+
+/**
+ * Concatenate tensors along an existing axis.
+ *
+ * All tensors must have the same shape except in the concatenation dimension.
+ * The output dtype is determined by the first tensor.
+ *
+ * **Complexity**: O(n) where n is total number of elements
+ *
+ * @param tensors - Array of tensors to concatenate
+ * @param axis - Axis along which to concatenate (default: 0)
+ * @returns Concatenated tensor
+ *
+ * @example
+ * ```ts
+ * const a = tensor([[1, 2], [3, 4]]);
+ * const b = tensor([[5, 6]]);
+ * const c = concatenate([a, b], 0);  // [[1, 2], [3, 4], [5, 6]]
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.concatenate.html | NumPy concatenate}
+ */
+declare function concatenate(tensors: Tensor[], axis?: Axis): Tensor;
+/**
+ * Stack tensors along a new axis.
+ *
+ * All tensors must have exactly the same shape.
+ * Creates a new dimension at the specified axis.
+ *
+ * **Complexity**: O(n) where n is total number of elements
+ *
+ * @param tensors - Array of tensors to stack
+ * @param axis - Axis along which to stack (default: 0)
+ * @returns Stacked tensor
+ *
+ * @example
+ * ```ts
+ * const a = tensor([1, 2, 3]);
+ * const b = tensor([4, 5, 6]);
+ * const c = stack([a, b], 0);  // [[1, 2, 3], [4, 5, 6]]
+ * const d = stack([a, b], 1);  // [[1, 4], [2, 5], [3, 6]]
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.stack.html | NumPy stack}
+ */
+declare function stack(tensors: Tensor[], axis?: Axis): Tensor;
+/**
+ * Split tensor into multiple sub-tensors along an axis.
+ *
+ * If indices_or_sections is an integer, the tensor is split into that many
+ * equal parts (axis dimension must be divisible).
+ * If it's an array, it specifies the indices where to split.
+ *
+ * **Complexity**: O(n) where n is total number of elements
+ *
+ * @param t - Input tensor
+ * @param indices_or_sections - Number of sections or array of split indices
+ * @param axis - Axis along which to split (default: 0)
+ * @returns Array of sub-tensors
+ *
+ * @example
+ * ```ts
+ * const t = tensor([1, 2, 3, 4, 5, 6]);
+ * const parts = split(t, 3);  // [tensor([1, 2]), tensor([3, 4]), tensor([5, 6])]
+ * const parts2 = split(t, [2, 4]);  // [tensor([1, 2]), tensor([3, 4]), tensor([5, 6])]
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.split.html | NumPy split}
+ */
+declare function split(t: Tensor, indices_or_sections: number | number[], axis?: Axis): Tensor[];
+/**
+ * Repeat tensor along axes by tiling.
+ *
+ * Constructs a tensor by repeating the input tensor the specified number
+ * of times along each axis.
+ *
+ * **Complexity**: O(n * product(reps)) where n is input size
+ *
+ * @param t - Input tensor
+ * @param reps - Number of repetitions along each axis
+ * @returns Tiled tensor
+ *
+ * @example
+ * ```ts
+ * const t = tensor([[1, 2], [3, 4]]);
+ * const tiled = tile(t, [2, 3]);
+ * // [[1, 2, 1, 2, 1, 2],
+ * //  [3, 4, 3, 4, 3, 4],
+ * //  [1, 2, 1, 2, 1, 2],
+ * //  [3, 4, 3, 4, 3, 4]]
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.tile.html | NumPy tile}
+ */
+declare function tile(t: Tensor, reps: number[]): Tensor;
+/**
+ * Repeat elements of a tensor along an axis.
+ *
+ * Each element is repeated the specified number of times.
+ *
+ * **Complexity**: O(n * repeats) where n is input size
+ *
+ * @param t - Input tensor
+ * @param repeats - Number of times to repeat each element
+ * @param axis - Axis along which to repeat (default: flatten first)
+ * @returns Tensor with repeated elements
+ *
+ * @example
+ * ```ts
+ * const t = tensor([1, 2, 3]);
+ * const r = repeat(t, 2);  // [1, 1, 2, 2, 3, 3]
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.repeat.html | NumPy repeat}
+ */
+declare function repeat(t: Tensor, repeats: number, axis?: Axis): Tensor;
+
+/**
+ * Element-wise exponential.
+ *
+ * Output dtype:
+ * - Always `float64` for now.
+ */
+declare function exp(t: Tensor): Tensor;
+/**
+ * Element-wise natural logarithm.
+ *
+ * @param t - Input tensor
+ * @returns Tensor with log(x) for each element
+ *
+ * @example
+ * ```ts
+ * import { log, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([1, 2.71828, 7.389]);
+ * const result = log(x);  // [0, 1, 2]
+ * ```
+ */
+declare function log(t: Tensor): Tensor;
+/**
+ * Element-wise square root.
+ *
+ * @param t - Input tensor
+ * @returns Tensor with sqrt(x) for each element
+ *
+ * @example
+ * ```ts
+ * import { sqrt, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([4, 9, 16]);
+ * const result = sqrt(x);  // [2, 3, 4]
+ * ```
+ */
+declare function sqrt(t: Tensor): Tensor;
+/**
+ * Element-wise square.
+ *
+ * @example
+ * ```ts
+ * import { square, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([1, 2, 3]);
+ * const result = square(x);  // [1, 4, 9]
+ * ```
+ */
+declare function square(t: Tensor): Tensor;
+/**
+ * Element-wise reciprocal square root.
+ *
+ * Returns 1/sqrt(x) for each element.
+ *
+ * @example
+ * ```ts
+ * import { rsqrt, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([4, 9, 16]);
+ * const result = rsqrt(x);  // [0.5, 0.333..., 0.25]
+ * ```
+ */
+declare function rsqrt(t: Tensor): Tensor;
+/**
+ * Element-wise cube root.
+ *
+ * @example
+ * ```ts
+ * import { cbrt, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([8, 27, 64]);
+ * const result = cbrt(x);  // [2, 3, 4]
+ * ```
+ */
+declare function cbrt(t: Tensor): Tensor;
+/**
+ * Element-wise exp(x) - 1.
+ *
+ * More accurate than exp(x) - 1 for small x.
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.expm1.html | NumPy expm1}
+ */
+declare function expm1(t: Tensor): Tensor;
+/**
+ * Element-wise base-2 exponential.
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.exp2.html | NumPy exp2}
+ */
+declare function exp2(t: Tensor): Tensor;
+/**
+ * Element-wise log(1 + x).
+ *
+ * More accurate than log(1 + x) for small x.
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.log1p.html | NumPy log1p}
+ */
+declare function log1p(t: Tensor): Tensor;
+/**
+ * Element-wise base-2 logarithm.
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.log2.html | NumPy log2}
+ */
+declare function log2(t: Tensor): Tensor;
+/**
+ * Element-wise base-10 logarithm.
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.log10.html | NumPy log10}
+ */
+declare function log10(t: Tensor): Tensor;
+/**
+ * Element-wise floor (round down).
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.floor.html | NumPy floor}
+ */
+declare function floor(t: Tensor): Tensor;
+/**
+ * Element-wise ceil (round up).
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.ceil.html | NumPy ceil}
+ */
+declare function ceil(t: Tensor): Tensor;
+/**
+ * Element-wise round to nearest integer.
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.round.html | NumPy round}
+ */
+declare function round(t: Tensor): Tensor;
+/**
+ * Element-wise truncate (round toward zero).
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.trunc.html | NumPy trunc}
+ */
+declare function trunc(t: Tensor): Tensor;
+
+type NumericDType = Exclude<DType, "string">;
+/**
+ * Generate a tensor of Bernoulli samples scaled by a constant.
+ *
+ * Each element is independently drawn: it equals `scale` with probability
+ * `(1 - p)` and `0` with probability `p`. This is the mask used by inverted
+ * dropout: non-dropped elements are pre-scaled by `1 / (1 - p)`.
+ *
+ * @param shape  - Output tensor shape
+ * @param p      - Probability of an element being zero (drop probability)
+ * @param scale  - Value assigned to kept elements (typically `1 / (1 - p)`)
+ * @param dtype  - Numeric dtype for the output tensor
+ * @param device - Target device
+ * @returns Tensor of the given shape filled with `0` or `scale`
+ *
+ * @internal
+ */
+declare function dropoutMask(shape: Shape, p: number, scale: number, dtype: NumericDType, device: Device): Tensor;
+
+/**
+ * Sum reduction.
+ *
+ * Supported (initial foundation):
+ * - `axis` omitted: sum all elements to a scalar tensor
+ * - `axis` provided: supports any axis
+ *
+ * Output dtype:
+ * - `int64` stays `int64`
+ * - `float32` and `float64` promote to `float64`
+ * - `int32`/`uint8`/`bool` promote to `int32`
+ * - `string` is unsupported
+ */
+declare function sum(t: Tensor, axis?: Axis, keepdims?: boolean): Tensor;
+/**
+ * Compute the arithmetic mean along the specified axis.
+ *
+ * Returns NaN for empty reductions (when the number of elements along the
+ * reduction axis is 0), matching NumPy's behavior of returning NaN with a
+ * "mean of empty slice" warning.
+ *
+ * @param t - Input tensor
+ * @param axis - Axis along which to compute mean. If undefined, compute over all elements
+ * @param keepdims - If true, keep reduced dimensions as size 1
+ * @returns Tensor containing mean values. NaN for empty reductions.
+ *
+ * @example
+ * ```ts
+ * import { mean, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([[1, 2], [3, 4]]);
+ * const m1 = mean(x);           // 2.5
+ * const m2 = mean(x, 0);        // [2, 3]
+ * const m3 = mean(x, 1);        // [1.5, 3.5]
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.mean.html | NumPy mean}
+ */
+declare function mean(t: Tensor, axis?: Axis, keepdims?: boolean): Tensor;
+/**
+ * Product of array elements along axis.
+ *
+ * Multiplies all elements together. Returns 1 for empty arrays.
+ * Supports full reduction and reduction over one or more axes.
+ *
+ * **Complexity**: O(n) where n is the number of elements
+ *
+ * Output dtype:
+ * - Same as input dtype (int32, float64, int64)
+ * - Potential for overflow with large products
+ *
+ * @param t - Input tensor
+ * @param axis - Axis or axes along which to compute the product
+ * @param keepdims - If true, keep reduced dimensions as size 1
+ * @returns Scalar tensor containing the product
+ *
+ * @example
+ * ```ts
+ * import { tensor, prod } from 'deepbox/ndarray';
+ *
+ * const t = tensor([1, 2, 3, 4]);
+ * prod(t);  // tensor(24) - 1*2*3*4
+ *
+ * const t2 = tensor([2.5, 4.0]);
+ * prod(t2);  // tensor(10.0)
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.prod.html | NumPy prod}
+ */
+declare function prod(t: Tensor, axis?: Axis | Axis[], keepdims?: boolean): Tensor;
+/**
+ * Standard deviation along axis.
+ *
+ * Computes the standard deviation, a measure of the spread of a distribution.
+ * Uses the formula: sqrt(variance)
+ *
+ * **Complexity**: O(n) where n is the number of elements (requires 2 passes)
+ *
+ * @param t - Input tensor
+ * @param axis - Axis or axes along which to compute std. If undefined, compute over all elements
+ * @param keepdims - If true, keep reduced dimensions as size 1
+ * @param ddof - Delta degrees of freedom (default 0 for population, 1 for sample)
+ * @returns Tensor containing the standard deviation values
+ *
+ * @example
+ * ```ts
+ * import { tensor, std } from 'deepbox/ndarray';
+ *
+ * const t = tensor([1, 2, 3, 4, 5]);
+ * std(t);  // tensor(1.414...) - population std
+ * std(t, undefined, false, 1);  // sample std
+ *
+ * const t2 = tensor([[1, 2], [3, 4]]);
+ * std(t2, 0);  // [1, 1] - std along rows
+ * std(t2, 1);  // [0.5, 0.5] - std along columns
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.std.html | NumPy std}
+ */
+declare function std(t: Tensor, axis?: Axis, keepdims?: boolean, ddof?: number): Tensor;
+/**
+ * Variance along axis.
+ *
+ * Computes the variance, the average of squared deviations from the mean.
+ * Formula: Σ(x - mean)² / (N - ddof)
+ *
+ * **Complexity**: O(n) where n is the number of elements (requires 2 passes: one for mean, one for variance)
+ *
+ * @param t - Input tensor
+ * @param axis - Axis along which to compute variance. If undefined, compute over all elements
+ * @param keepdims - If true, keep reduced dimensions as size 1
+ * @param ddof - Delta degrees of freedom (default 0 for population, 1 for sample)
+ * @returns Tensor containing the variance values
+ *
+ * @example
+ * ```ts
+ * import { tensor, variance } from 'deepbox/ndarray';
+ *
+ * const t = tensor([1, 2, 3, 4, 5]);
+ * variance(t);  // tensor(2.0) - population variance
+ * variance(t, undefined, false, 1);  // tensor(2.5) - sample variance
+ *
+ * const t2 = tensor([[1, 2], [3, 4]]);
+ * variance(t2, 0);  // [1, 1] - variance along rows
+ * variance(t2, 1);  // [0.25, 0.25] - variance along columns
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.var.html | NumPy var}
+ */
+declare function variance(t: Tensor, axis?: Axis, keepdims?: boolean, ddof?: number): Tensor;
+/**
+ * Minimum value along axis.
+ *
+ * Finds the smallest element in the tensor, optionally along one or more axes.
+ *
+ * **Complexity**: O(n) where n is the number of elements
+ *
+ * @param t - Input tensor
+ * @param axis - Axis or axes along which to compute the minimum
+ * @param keepdims - If true, keep reduced dimensions as size 1
+ * @returns Scalar tensor containing the minimum value
+ *
+ * @example
+ * ```ts
+ * import { tensor, min } from 'deepbox/ndarray';
+ *
+ * const t = tensor([3, 1, 4, 1, 5]);
+ * min(t);  // tensor(1)
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.amin.html | NumPy amin}
+ */
+declare function min(t: Tensor, axis?: Axis | Axis[], keepdims?: boolean): Tensor;
+/**
+ * Maximum value along axis.
+ *
+ * Finds the largest element in the tensor, optionally along one or more axes.
+ *
+ * **Complexity**: O(n) where n is the number of elements
+ *
+ * @param t - Input tensor
+ * @param axis - Axis or axes along which to compute the maximum
+ * @param keepdims - If true, keep reduced dimensions as size 1
+ * @returns Scalar tensor containing the maximum value
+ *
+ * @example
+ * ```ts
+ * import { tensor, max } from 'deepbox/ndarray';
+ *
+ * const t = tensor([3, 1, 4, 1, 5]);
+ * max(t);  // tensor(5)
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.amax.html | NumPy amax}
+ */
+declare function max(t: Tensor, axis?: Axis | Axis[], keepdims?: boolean): Tensor;
+/**
+ * Median value along axis.
+ *
+ * Computes the median (middle value) of the data.
+ * For even-sized arrays, returns the average of the two middle values.
+ *
+ * **Complexity**: O(n log n) due to sorting per output element
+ *
+ * @param t - Input tensor
+ * @param axis - Axis along which to compute median. If undefined, compute over all elements
+ * @param keepdims - If true, keep reduced dimensions as size 1
+ * @returns Tensor containing the median values
+ *
+ * @example
+ * ```ts
+ * import { tensor, median } from 'deepbox/ndarray';
+ *
+ * const t = tensor([1, 3, 5, 7, 9]);
+ * median(t);  // tensor(5) - middle value
+ *
+ * const t2 = tensor([1, 2, 3, 4]);
+ * median(t2);  // tensor(2.5) - average of 2 and 3
+ *
+ * const t3 = tensor([[1, 3], [2, 4]]);
+ * median(t3, 0);  // [1.5, 3.5] - median along rows
+ * median(t3, 1);  // [2, 3] - median along columns
+ * ```
+ *
+ * Performance:
+ * - This implementation copies and sorts values (O(n log n) time, O(n) memory).
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.median.html | NumPy median}
+ */
+declare function median(t: Tensor, axis?: Axis, keepdims?: boolean): Tensor;
+/**
+ * Cumulative sum along axis.
+ *
+ * Returns an array of the same shape where each element is the sum of all
+ * previous elements (inclusive) along the specified axis.
+ *
+ * **Complexity**: O(n) where n is the number of elements
+ *
+ * @param t - Input tensor
+ * @param axis - Axis along which to compute cumulative sum. If undefined, operates on the flattened array.
+ * @returns Tensor of same shape with cumulative sums
+ *
+ * @example
+ * ```ts
+ * import { tensor, cumsum } from 'deepbox/ndarray';
+ *
+ * const t = tensor([1, 2, 3, 4]);
+ * cumsum(t);  // tensor([1, 3, 6, 10])
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.cumsum.html | NumPy cumsum}
+ */
+declare function cumsum(t: Tensor, axis?: Axis): Tensor;
+/**
+ * Cumulative product along axis.
+ *
+ * Returns an array of the same shape where each element is the product of all
+ * previous elements (inclusive) along the specified axis.
+ *
+ * **Complexity**: O(n) where n is the number of elements
+ *
+ * @param t - Input tensor
+ * @param axis - Axis along which to compute cumulative product. If undefined, operates on the flattened array.
+ * @returns Tensor of same shape with cumulative products
+ *
+ * @example
+ * ```ts
+ * import { tensor, cumprod } from 'deepbox/ndarray';
+ *
+ * const t = tensor([1, 2, 3, 4]);
+ * cumprod(t);  // tensor([1, 2, 6, 24])
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.cumprod.html | NumPy cumprod}
+ */
+declare function cumprod(t: Tensor, axis?: Axis): Tensor;
+/**
+ * Calculate differences along axis.
+ *
+ * Computes the n-th discrete difference along the given axis.
+ * The first difference is given by out[i] = a[i+1] - a[i] along the flattened array.
+ * Computes differences along the specified axis (default: last axis).
+ *
+ * **Complexity**: O(n) where n is the number of elements
+ *
+ * @param t - Input tensor
+ * @param n - Number of times to take difference (default 1)
+ * @param axis - Axis along which to compute differences (default: last axis)
+ * @returns Tensor with differences (size reduced by n along the given axis)
+ *
+ * @example
+ * ```ts
+ * import { tensor, diff } from 'deepbox/ndarray';
+ *
+ * const t = tensor([1, 3, 6, 10]);
+ * diff(t);  // tensor([2, 3, 4]) - differences between consecutive elements
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.diff.html | NumPy diff}
+ */
+declare function diff(t: Tensor, n?: number, axis?: number): Tensor;
+/**
+ * Test whether any array element evaluates to True (non-zero).
+ *
+ * Returns true if at least one element is non-zero, false if all are zero.
+ * Supports reduction over one or more axes.
+ *
+ * **Complexity**: O(n) - checks each element until finding non-zero or reaching end
+ *
+ * @param t - Input tensor
+ * @param axis - Axis or axes along which to compute the reduction
+ * @param keepdims - If true, keep reduced dimensions as size 1
+ * @returns Scalar tensor (true=1, false=0)
+ *
+ * @example
+ * ```ts
+ * const t = tensor([0, 0, 1, 0]);
+ * any(t);  // tensor(1) - at least one non-zero
+ *
+ * const t2 = tensor([0, 0, 0]);
+ * any(t2);  // tensor(0) - all zeros
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.any.html | NumPy any}
+ */
+declare function any(t: Tensor, axis?: number | number[], keepdims?: boolean): Tensor;
+/**
+ * Test whether all array elements evaluate to True (non-zero).
+ *
+ * Returns true only if all elements are non-zero, false if any are zero.
+ * Supports reduction over one or more axes.
+ *
+ * **Complexity**: O(n) - checks each element until finding zero or reaching end
+ *
+ * @param t - Input tensor
+ * @param axis - Axis or axes along which to compute the reduction
+ * @param keepdims - If true, keep reduced dimensions as size 1
+ * @returns Scalar tensor (true=1, false=0)
+ *
+ * @example
+ * ```ts
+ * const t = tensor([1, 2, 3]);
+ * all(t);  // tensor(1) - all non-zero
+ *
+ * const t2 = tensor([1, 0, 3]);
+ * all(t2);  // tensor(0) - has a zero
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.all.html | NumPy all}
+ */
+declare function all(t: Tensor, axis?: number | number[], keepdims?: boolean): Tensor;
+
+/**
+ * Sort values along a given axis.
+ *
+ * Supports tensors of any dimensionality.  Default axis is -1 (last).
+ *
+ * Performance:
+ * - O(N log N) where N is the total number of elements.
+ */
+declare function sort(t: Tensor, axis?: Axis | undefined, descending?: boolean): Tensor;
+/**
+ * Return indices that would sort the tensor along a given axis.
+ *
+ * Supports tensors of any dimensionality.  Default axis is -1 (last).
+ *
+ * Performance:
+ * - O(N log N) where N is the total number of elements.
+ */
+declare function argsort(t: Tensor, axis?: Axis | undefined, descending?: boolean): Tensor;
+
+/**
+ * Element-wise sine.
+ *
+ * Output dtype:
+ * - Always `float64` for now.
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.sin.html | NumPy sin}
+ */
+declare function sin(t: Tensor): Tensor;
+/**
+ * Element-wise cosine.
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.cos.html | NumPy cos}
+ */
+declare function cos(t: Tensor): Tensor;
+/**
+ * Element-wise tangent.
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.tan.html | NumPy tan}
+ */
+declare function tan(t: Tensor): Tensor;
+/**
+ * Element-wise inverse sine.
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.arcsin.html | NumPy arcsin}
+ */
+declare function asin(t: Tensor): Tensor;
+/**
+ * Element-wise inverse cosine.
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.arccos.html | NumPy arccos}
+ */
+declare function acos(t: Tensor): Tensor;
+/**
+ * Element-wise inverse tangent.
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.arctan.html | NumPy arctan}
+ */
+declare function atan(t: Tensor): Tensor;
+/**
+ * Element-wise arctangent of y/x with correct quadrant.
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.arctan2.html | NumPy arctan2}
+ */
+declare function atan2(y: Tensor, x: Tensor): Tensor;
+/**
+ * Element-wise hyperbolic sine.
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.sinh.html | NumPy sinh}
+ */
+declare function sinh(t: Tensor): Tensor;
+/**
+ * Element-wise hyperbolic cosine.
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.cosh.html | NumPy cosh}
+ */
+declare function cosh(t: Tensor): Tensor;
+/**
+ * Element-wise hyperbolic tangent.
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.tanh.html | NumPy tanh}
+ */
+declare function tanh(t: Tensor): Tensor;
+/**
+ * Element-wise inverse hyperbolic sine.
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.arcsinh.html | NumPy arcsinh}
+ */
+declare function asinh(t: Tensor): Tensor;
+/**
+ * Element-wise inverse hyperbolic cosine.
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.arccosh.html | NumPy arccosh}
+ */
+declare function acosh(t: Tensor): Tensor;
+/**
+ * Element-wise inverse hyperbolic tangent.
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.arctanh.html | NumPy arctanh}
+ */
+declare function atanh(t: Tensor): Tensor;
+
+/**
+ * Remove single-dimensional entries from the shape.
+ *
+ * Returns a view of the tensor with all dimensions of size 1 removed.
+ * If axis is specified, only removes dimensions at those positions.
+ *
+ * **Complexity**: O(ndim) - only manipulates shape metadata, no data copy
+ *
+ * **Parameters**:
+ * @param t - Input tensor
+ * @param axis - Axis to squeeze. If undefined, squeeze all axes of size 1
+ *
+ * **Returns**: Tensor with squeezed dimensions (view, no copy)
+ *
+ * @example
+ * ```ts
+ * import { squeeze, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([[[1], [2], [3]]]);
+  // shape: (1, 3, 1)
+ * const y = squeeze(x);                  // shape: (3,)
+ * const z = squeeze(x, 2);               // shape: (1, 3)
+ * ```
+ *
+ * @throws {Error} If axis is specified and dimension is not 1
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.squeeze.html | NumPy squeeze}
+ */
+declare function squeeze(t: Tensor, axis?: Axis | Axis[]): Tensor;
+/**
+ * Expand the shape by inserting a new axis.
+ *
+ * Returns a view of the tensor with a new dimension of size 1 inserted
+ * at the specified position.
+ *
+ * **Complexity**: O(ndim) - only manipulates shape metadata, no data copy
+ *
+ * **Parameters**:
+ * @param t - Input tensor
+ * @param axis - Position where new axis is placed (can be negative)
+ *
+ * **Returns**: Tensor with expanded dimensions (view, no copy)
+ *
+ * @example
+ * ```ts
+ * import { unsqueeze, tensor } from 'deepbox/ndarray';
+ *
+ * const x = tensor([1, 2, 3]);     // shape: (3,)
+ * const y = unsqueeze(x, 0);       // shape: (1, 3)
+ * const z = unsqueeze(x, 1);       // shape: (3, 1)
+ * const w = unsqueeze(x, -1);      // shape: (3, 1)
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.expand_dims.html | NumPy expand_dims}
+ */
+declare function unsqueeze(t: Tensor, axis: number): Tensor;
+/**
+ * Alias for unsqueeze.
+ */
+declare const expandDims: typeof unsqueeze;
+
+/**
+ * Union type representing either a Tensor or GradTensor.
+ *
+ * This type enables functions to accept both regular tensors and
+ * differentiable tensors interchangeably, improving API flexibility.
+ *
+ * Use this type when a function should work with either tensor type:
+ * - `Tensor`: For pure numerical operations without gradient tracking
+ * - `GradTensor`: For operations that need automatic differentiation
+ *
+ * @example
+ * ```ts
+ * import type { AnyTensor } from 'deepbox/ndarray';
+ *
+ * function processData(input: AnyTensor): void {
+ *   console.log(input.shape);  // Works with both Tensor and GradTensor
+ *   console.log(input.dtype);
+ * }
+ * ```
+ */
+type AnyTensor = Tensor | GradTensor;
+
+type index_AnyTensor = AnyTensor;
+declare const index_CSRMatrix: typeof CSRMatrix;
+declare const index_CSRMatrixInit: typeof CSRMatrixInit;
+declare const index_DType: typeof DType;
+declare const index_Device: typeof Device;
+declare const index_GradTensor: typeof GradTensor;
+declare const index_GradTensorOptions: typeof GradTensorOptions;
+type index_NestedArray = NestedArray;
+declare const index_Shape: typeof Shape;
+declare const index_SliceRange: typeof SliceRange;
+declare const index_Tensor: typeof Tensor;
+type index_TensorCreateOptions = TensorCreateOptions;
+declare const index_TensorLike: typeof TensorLike;
+declare const index_TensorOptions: typeof TensorOptions;
+declare const index_TypedArray: typeof TypedArray;
+declare const index_abs: typeof abs;
+declare const index_acos: typeof acos;
+declare const index_acosh: typeof acosh;
+declare const index_add: typeof add;
+declare const index_addScalar: typeof addScalar;
+declare const index_all: typeof all;
+declare const index_allclose: typeof allclose;
+declare const index_any: typeof any;
+declare const index_arange: typeof arange;
+declare const index_argsort: typeof argsort;
+declare const index_arrayEqual: typeof arrayEqual;
+declare const index_asin: typeof asin;
+declare const index_asinh: typeof asinh;
+declare const index_atan: typeof atan;
+declare const index_atan2: typeof atan2;
+declare const index_atanh: typeof atanh;
+declare const index_cbrt: typeof cbrt;
+declare const index_ceil: typeof ceil;
+declare const index_clip: typeof clip;
+declare const index_col2im: typeof col2im;
+declare const index_concatenate: typeof concatenate;
+declare const index_cos: typeof cos;
+declare const index_cosh: typeof cosh;
+declare const index_cumprod: typeof cumprod;
+declare const index_cumsum: typeof cumsum;
+declare const index_diff: typeof diff;
+declare const index_div: typeof div;
+declare const index_dot: typeof dot;
+declare const index_dropoutMask: typeof dropoutMask;
+declare const index_elu: typeof elu;
+declare const index_empty: typeof empty;
+declare const index_equal: typeof equal;
+declare const index_exp: typeof exp;
+declare const index_exp2: typeof exp2;
+declare const index_expandDims: typeof expandDims;
+declare const index_expm1: typeof expm1;
+declare const index_eye: typeof eye;
+declare const index_flatten: typeof flatten;
+declare const index_floor: typeof floor;
+declare const index_floorDiv: typeof floorDiv;
+declare const index_full: typeof full;
+declare const index_gather: typeof gather;
+declare const index_gelu: typeof gelu;
+declare const index_geomspace: typeof geomspace;
+declare const index_greater: typeof greater;
+declare const index_greaterEqual: typeof greaterEqual;
+declare const index_im2col: typeof im2col;
+declare const index_isclose: typeof isclose;
+declare const index_isfinite: typeof isfinite;
+declare const index_isinf: typeof isinf;
+declare const index_isnan: typeof isnan;
+declare const index_leakyRelu: typeof leakyRelu;
+declare const index_less: typeof less;
+declare const index_lessEqual: typeof lessEqual;
+declare const index_linspace: typeof linspace;
+declare const index_log: typeof log;
+declare const index_log10: typeof log10;
+declare const index_log1p: typeof log1p;
+declare const index_log2: typeof log2;
+declare const index_logSoftmax: typeof logSoftmax;
+declare const index_logicalAnd: typeof logicalAnd;
+declare const index_logicalNot: typeof logicalNot;
+declare const index_logicalOr: typeof logicalOr;
+declare const index_logicalXor: typeof logicalXor;
+declare const index_logspace: typeof logspace;
+declare const index_max: typeof max;
+declare const index_maximum: typeof maximum;
+declare const index_mean: typeof mean;
+declare const index_median: typeof median;
+declare const index_min: typeof min;
+declare const index_minimum: typeof minimum;
+declare const index_mish: typeof mish;
+declare const index_mod: typeof mod;
+declare const index_mul: typeof mul;
+declare const index_mulScalar: typeof mulScalar;
+declare const index_neg: typeof neg;
+declare const index_noGrad: typeof noGrad;
+declare const index_notEqual: typeof notEqual;
+declare const index_ones: typeof ones;
+declare const index_parameter: typeof parameter;
+declare const index_pow: typeof pow;
+declare const index_prod: typeof prod;
+declare const index_randn: typeof randn;
+declare const index_reciprocal: typeof reciprocal;
+declare const index_relu: typeof relu;
+declare const index_repeat: typeof repeat;
+declare const index_reshape: typeof reshape;
+declare const index_round: typeof round;
+declare const index_rsqrt: typeof rsqrt;
+declare const index_sigmoid: typeof sigmoid;
+declare const index_sign: typeof sign;
+declare const index_sin: typeof sin;
+declare const index_sinh: typeof sinh;
+declare const index_slice: typeof slice;
+declare const index_softmax: typeof softmax;
+declare const index_softplus: typeof softplus;
+declare const index_sort: typeof sort;
+declare const index_split: typeof split;
+declare const index_sqrt: typeof sqrt;
+declare const index_square: typeof square;
+declare const index_squeeze: typeof squeeze;
+declare const index_stack: typeof stack;
+declare const index_std: typeof std;
+declare const index_sub: typeof sub;
+declare const index_sum: typeof sum;
+declare const index_swish: typeof swish;
+declare const index_tan: typeof tan;
+declare const index_tanh: typeof tanh;
+declare const index_tensor: typeof tensor;
+declare const index_tile: typeof tile;
+declare const index_transpose: typeof transpose;
+declare const index_trunc: typeof trunc;
+declare const index_unsqueeze: typeof unsqueeze;
+declare const index_variance: typeof variance;
+declare const index_zeros: typeof zeros;
+declare namespace index {
+  export { type index_AnyTensor as AnyTensor, index_CSRMatrix as CSRMatrix, index_CSRMatrixInit as CSRMatrixInit, index_DType as DType, index_Device as Device, index_GradTensor as GradTensor, index_GradTensorOptions as GradTensorOptions, type index_NestedArray as NestedArray, index_Shape as Shape, index_SliceRange as SliceRange, index_Tensor as Tensor, type index_TensorCreateOptions as TensorCreateOptions, index_TensorLike as TensorLike, index_TensorOptions as TensorOptions, index_TypedArray as TypedArray, index_abs as abs, index_acos as acos, index_acosh as acosh, index_add as add, index_addScalar as addScalar, index_all as all, index_allclose as allclose, index_any as any, index_arange as arange, index_argsort as argsort, index_arrayEqual as arrayEqual, index_asin as asin, index_asinh as asinh, index_atan as atan, index_atan2 as atan2, index_atanh as atanh, index_cbrt as cbrt, index_ceil as ceil, index_clip as clip, index_col2im as col2im, index_concatenate as concatenate, index_cos as cos, index_cosh as cosh, index_cumprod as cumprod, index_cumsum as cumsum, index_diff as diff, index_div as div, index_dot as dot, dropout as dropoutGrad, index_dropoutMask as dropoutMask, index_elu as elu, index_empty as empty, index_equal as equal, index_exp as exp, index_exp2 as exp2, index_expandDims as expandDims, index_expm1 as expm1, index_eye as eye, index_flatten as flatten, index_floor as floor, index_floorDiv as floorDiv, index_full as full, index_gather as gather, index_gelu as gelu, index_geomspace as geomspace, index_greater as greater, index_greaterEqual as greaterEqual, index_im2col as im2col, im2col$1 as im2colGrad, index_isclose as isclose, index_isfinite as isfinite, index_isinf as isinf, index_isnan as isnan, index_leakyRelu as leakyRelu, index_less as less, index_lessEqual as lessEqual, index_linspace as linspace, index_log as log, index_log10 as log10, index_log1p as log1p, index_log2 as log2, index_logSoftmax as logSoftmax, logSoftmax$1 as logSoftmaxGrad, index_logicalAnd as logicalAnd, index_logicalNot as logicalNot, index_logicalOr as logicalOr, index_logicalXor as logicalXor, index_logspace as logspace, index_max as max, index_maximum as maximum, index_mean as mean, index_median as median, index_min as min, index_minimum as minimum, index_mish as mish, index_mod as mod, index_mul as mul, index_mulScalar as mulScalar, index_neg as neg, index_noGrad as noGrad, index_notEqual as notEqual, index_ones as ones, index_parameter as parameter, index_pow as pow, index_prod as prod, index_randn as randn, index_reciprocal as reciprocal, index_relu as relu, index_repeat as repeat, index_reshape as reshape, index_round as round, index_rsqrt as rsqrt, index_sigmoid as sigmoid, index_sign as sign, index_sin as sin, index_sinh as sinh, index_slice as slice, index_softmax as softmax, softmax$1 as softmaxGrad, index_softplus as softplus, index_sort as sort, index_split as split, index_sqrt as sqrt, index_square as square, index_squeeze as squeeze, index_stack as stack, index_std as std, index_sub as sub, index_sum as sum, index_swish as swish, index_tan as tan, index_tanh as tanh, index_tensor as tensor, index_tile as tile, index_transpose as transpose, index_trunc as trunc, index_unsqueeze as unsqueeze, index_variance as variance, variance$1 as varianceGrad, index_zeros as zeros };
+}
+
+export { lessEqual as $, type AnyTensor as A, atan as B, atan2 as C, atanh as D, cbrt as E, ceil as F, clip as G, concatenate as H, cos as I, cosh as J, cumprod as K, cumsum as L, diff as M, div as N, equal as O, exp as P, exp2 as Q, expm1 as R, floor as S, floorDiv as T, greater as U, greaterEqual as V, isclose as W, isfinite as X, isinf as Y, isnan as Z, less as _, logSoftmax as a, log as a0, log1p as a1, log2 as a2, log10 as a3, logicalAnd as a4, logicalNot as a5, logicalOr as a6, logicalXor as a7, max as a8, maximum as a9, tan as aA, tanh as aB, tile as aC, trunc as aD, variance as aE, dropoutMask as aF, type NestedArray as aG, type TensorCreateOptions as aH, arange as aI, empty as aJ, eye as aK, flatten as aL, full as aM, geomspace as aN, linspace as aO, logspace as aP, ones as aQ, randn as aR, reshape as aS, tensor as aT, transpose as aU, zeros as aV, expandDims as aW, squeeze as aX, unsqueeze as aY, mean as aa, median as ab, min as ac, minimum as ad, mod as ae, mul as af, mulScalar as ag, neg as ah, notEqual as ai, pow as aj, prod as ak, reciprocal as al, repeat as am, round as an, rsqrt as ao, sign as ap, sin as aq, sinh as ar, sort as as, split as at, sqrt as au, square as av, stack as aw, std as ax, sub as ay, sum as az, softmax as b, softplus as c, dot as d, elu as e, swish as f, gelu as g, col2im as h, index as i, im2col as j, abs as k, leakyRelu as l, mish as m, acos as n, acosh as o, add as p, addScalar as q, relu as r, sigmoid as s, all as t, allclose as u, any as v, argsort as w, arrayEqual as x, asin as y, asinh as z };