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