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.

Compute the minimum and maximum of input.

Phase angle (argument) of each element.

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.

Bartlett (triangular) window, periodic by default.

Blackman window, in the periodic form stft expects by default.

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

Return the common shape to which shapes broadcast.

Broadcast one or more tensors against each other to a common shape.

Predicate: can from_ be cast to to under the promotion rules?

Stack tensors as columns of a 2-D matrix.

Eagerly materialised complex conjugate.

Compute the running trapezoidal integral of y along dim.

Element-wise division — lucid.div under its longer name.

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.

Hamming window, or the two-term cosine window alpha/beta give.

Hann window, in the periodic form stft expects by default.

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.

Inverse short-time Fourier transform.

Kaiser window with shape parameter beta, periodic by default.

Return the logarithm of the cumulative sum of exponentials of input along dim.

Logit function — inverse of the logistic sigmoid.

Median of a tensor along dim (or over the whole tensor when None).

Return a (values, indices) pair of the modal value of each slice along dim.

Move one or more axes to new positions.

Sort the elements of input along its first dimension in ascending order.

Element-wise product.

Matrix-vector product.

Mean of the tensor, ignoring NaN entries.

Median of a tensor, ignoring NaN entries.

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.

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.

Compute the q-th quantile of input.

Rescale each sub-tensor along dim whose p-norm exceeds maxnorm.

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$.

Slice input along dim at index, removing that dimension.

Element-wise sign-bit predicate.

Normalised sinc function with the standard removable singularity at 0.

Short-time Fourier transform.

Element-wise subtraction with an optional scalar multiplier.

Return input 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 input at positions indices along dim.

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

Integrate y along dim using the composite trapezoidal rule.

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 y = 0$.

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

Element-wise sign transplant: magnitudes from input, signs from other.

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

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

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)$.

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

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: writes into input's storage.

Fill the positions where mask holds with source's leading elements.

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 input to per-slice maxima along dim — values only.

Reduce input 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.

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

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.

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

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

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