composite

Element-wise absolute value.

Inverse hyperbolic cosine.

Batched matmul with reduction over the batch axis.

Element-wise fused divide-add.

Element-wise fused multiply-add with a scalar weight.

General matrix multiply with a scaled accumulator (GEMM).

Matrix-vector multiply with a scaled accumulator (BLAS-2 gemv).

Rank-1 update of a matrix by an outer product (BLAS-2 ger).

Conjugate (Hermitian) transpose of the trailing two dimensions.

Phase angle (argument) of a complex tensor.

Inverse hyperbolic cosine.

Inverse hyperbolic sine.

Quadrant-correct two-argument arctangent.

Inverse hyperbolic tangent.

Inverse hyperbolic sine.

Inverse hyperbolic tangent.

Promote each input to at least 1 dimension.

Promote each input to at least 2 dimensions.

Promote each input to at least 3 dimensions.

Batched GEMM with a batched accumulator.

Construct a block-diagonal matrix from a sequence of blocks.

Predicate: can from_dtype be safely cast to to_dtype?

Stack tensors as columns of a 2-D matrix.

Eagerly materialised complex conjugate.

Element-wise true division.

Split a tensor along its third (depth) axis.

Stack tensors along the third (depth) axis.

Element-wise $e^{x} - 1$.

Element-wise power that always promotes operands to float64.

Element-wise NaN-quiet maximum.

Element-wise NaN-quiet minimum.

Outer product of two 1-D tensors.

Heaviside step function with a user-selectable value at $x = 0$.

Split a tensor horizontally (along axis 1 for rank $\geq 2$).

Predicate: does the tensor carry a lazy "conjugated" flag?

Predicate: does the tensor carry a lazy "negated" flag?

Predicate: is a single-element tensor non-zero?

Predicate: do two tensors have identical shapes?

Predicate: is the object a separate Storage container?

Per-element set-membership test.

Element-wise test for negative infinity.

Element-wise test for positive infinity.

Element-wise test for real-valued entries.

Logit function — inverse of the logistic sigmoid.

Move one or more axes to new positions.

Element-wise product.

Matrix-vector product.

Mean of the tensor, ignoring NaN entries.

Median of a tensor, ignoring NaN entries.

Sum the tensor, treating NaN entries as zero.

Element-wise negation.

Return the total number of elements in a tensor.

Build a complex tensor from polar coordinates (magnitude, phase).

Element-wise identity — returns the input unchanged.

Compute the joint promotion of two dtypes.

Materialise any pending lazy conjugation — no-op in Lucid.

Materialise any pending lazy negation — no-op in Lucid.

Compute the dtype that a binary operation on the inputs would produce.

Rotate a tensor by 90° in a chosen plane.

Stack tensors as rows — alias of lucid.vstack.

Reverse subtraction: $b - \alpha \cdot a$.

Element-wise sign-bit predicate.

Normalised sinc function with the standard removable singularity at 0.

Element-wise subtraction with an optional scalar multiplier.

Return x with axes axis0 and axis1 exchanged.

Swap two named dimensions of a tensor.

Short-form transpose for tensors of rank at most 2.

Gather elements from x at positions indices along dim.

Split a tensor along dim, permitting unequal final-piece sizes.

Element-wise true (floating-point) division.

Vector dot product (complex-conjugating on the first argument).

Reinterpret a real tensor with a trailing pair axis as a complex tensor.

Reinterpret a complex tensor as a real tensor with a trailing pair axis.

Split a tensor along its first (vertical) axis.

Compute $x \log y$ with the convention $0 \cdot \log 0 = 0$.

Log-determinant of a square matrix (or batch).

Element-wise sign transplant: magnitudes from x, signs from y.

Embed the last dimension of x as the diagonal of a new matrix.

Digamma function $\psi(x) = \frac{d}{dx} \ln \Gamma(x)$.

Complementary error function $\text{erfc}(x) = 1 - \text{erf}(x)$.

Element-wise floor division — $\lfloor a / b \rfloor$.

Decompose input into mantissa m and exponent e such that input = m * 2**e with |m| in [0.5, 1) (or m == 0).

Element-wise greatest common divisor for integer tensors.

Modified Bessel function of the first kind, order 0: $I_0(x)$.

Element-wise least common multiple for integer tensors.

Element-wise $\text{input} \cdot 2^{\text{exponent}}$.

Natural log of the gamma function $\ln \Gamma(x)$.

Logarithm of softmax along dim: $\log \sigma(x)$.

Softmax along dim — $\sigma(x)_i = e^{x_i} / \sum_j e^{x_j}$.

Return the coordinates of every non-zero element in x.

Return input with alpha * source accumulated at index positions along dim.

Return a copy of input with slices at index replaced by source.

Return a copy of input with positions index along dim set to value.

Out-of-place advanced-indexing write.

In-place variant of index_put — mutates input so the write is visible through the same Tensor reference.

Copy elements from source into input at positions where mask is True.

Write source into input at the flat positions in index.

Reduce src into input along dim at positions given by index.

Return True iff every element pair is close within tolerance.

Reduce x to per-slice maxima along dim — values only.

Reduce x to per-slice minima along dim — values only.

Count non-zero elements along dim (or whole tensor when None).

All r-length combinations of the elements of a 1-D input.

Indices of the lower-triangular part of an (row, col) matrix.

Indices of the upper-triangular part of an (row, col) matrix.

Count occurrences of each integer value in input.

Pairwise $L_p$ distance matrix between rows of x1 and x2.

Pearson correlation-coefficient matrix.

Covariance matrix of input.

Compute a 1-D histogram of input values.

Joint 2-D histogram of paired observations (x[i], y[i]).

N-dimensional histogram for arbitrary sample dimension.

Draw num_samples indices from the categorical distribution defined by input.

NaN-aware quantile — same interface as quantile, but every NaN is excluded from the sort and the per-axis quantile is computed over the remaining values.

Sample element-wise from $\mathrm{Poisson}(\text{rate} = \text{input}[i])$.

Compute the q-th quantile of input.

Return (std, mean) along dim in a single call.

Return (var, mean) along dim in a single call.