Absolute value of this expression.

The unary and binary maths nodes follow the same rule as the arithmetic operators above: the node itself stays internal so only its @SerialName is a contract, and this factory is the Kotlin way to build one. Every node in this file must be reachable both ways - from Kotlin and from the wire - and a pipeline that can only be authored as JSON is not usable from Kotlin at all.

True when every input to the update is finite, whichever modality the stat is.

Use it through the filterFinite() shorthand on each spec type rather than by hand. Unlike isFinite, this covers a whole feature vector, which no per-coordinate expression can.

Short-circuiting conjunction.

Build Div of two expressions.

Divide this expression by a literal rhs.

Divide a literal receiver by an expression.

Exact equality (no tolerance).

Exact equality against a literal (no tolerance).

Exact equality with a literal left operand (no tolerance).

Evaluate this scalar expression against a borrowed KoBLAS vector without materialising it.

This overload is additive: ScalarExpr.eval with a DoubleArray remains the compatibility surface for callers whose input is already dense.

VFoldOp.Sum and VFoldOp.Mean reduce through koblas, which pairs terms across SIMD lanes for a dense operand and accumulates in order for every other storage. Those associate differently, so the same coordinates reduced from a dense vector and from a sparse one can disagree in the last bits, and a snapshot carrying such a value is only equal to another that was fed the same storage. Every other fold is order-independent and agrees exactly whatever the storage.

Evaluate this boolean expression against a borrowed KoBLAS vector without materialising it.

Evaluate this vector expression against a borrowed KoBLAS vector, allocating only its owned output.

e raised to this expression. Overflows to +Infinity well before Double runs out of range.

Greater-or-equal comparison.

Greater-or-equal against a literal.

Greater-or-equal with a literal left operand.

Strictly-greater-than comparison.

Strictly-greater-than against a literal.

Strictly-greater-than with a literal left operand.

then when cond holds, else otherwise; only the selected branch is evaluated. Builds an IfExpr.

then when cond holds, else otherwise, with a literal then branch.

then when cond holds, else otherwise, with a literal otherwise branch.

then when cond holds, else otherwise, with literal branches.

True when this expression falls within [min, max], both ends inclusive.

Distinct from x ge min and (x le max), which builds three nodes and evaluates this expression twice; a filter runs on every update, so the single-node form is the one to reach for.

True when this expression evaluates to a finite number: not NaN, and not an infinity.

Stronger than !isNaN(). Prefer it whenever the intent is "a real number", since an infinity passes every ordering comparison the AST can express.

Mean.filter(X.isFinite())

True when this expression evaluates to NaN.

A NaN observation propagates through every stat by default; see Stat. Pair this with not to drop them instead, which is the supported way to ask for that:

Mean.filter(!X.isNaN())

Less-or-equal comparison.

Less-or-equal against a literal.

Less-or-equal with a literal left operand.

Natural logarithm of this expression. ln(0) is -Infinity and a negative input gives NaN.

Strictly-less-than comparison.

Strictly-less-than against a literal.

Strictly-less-than with a literal left operand.

The larger of this expression and other.

The larger of this expression and a constant other.

The smaller of this expression and other.

The smaller of this expression and a constant other.

Build Sub of two expressions.

Subtract a literal rhs from this expression.

Subtract an expression from a literal receiver.

Exact inequality, the negation of eq under IEEE 754: true when either side is NaN, and false for 0.0 against -0.0. It builds !(this eq rhs), which encodes with the portable not and eq.

Exact inequality against a literal; see ne.

Exact inequality with a literal left operand; see ne.

Logical negation.

Short-circuiting disjunction.

Build Add of two expressions.

Add a literal rhs to this expression.

Add an expression to a literal receiver.

This expression raised to exponent.

This expression raised to a constant exponent.

This expression raised to an integer exponent, which binary64 represents exactly.

Square root of this expression. A negative input gives NaN.

Build Mul of two expressions.

Multiply this expression by a literal rhs.

Multiply a literal receiver by an expression.

Unary minus: wraps in Neg.

Weighted sum of the feature vector. weights must match the vector length at evaluation time.

Weighted sum of the feature vector, varargs form.

Build an output vector by evaluating each expression in order; output length is exprs.size.

The only VectorExpr constructor, and so the only way to reach transformVector / transformX from Kotlin. Reference input coordinates with V: vectorOf(V(2), V(0), V(1)) permutes, vectorOf((V(0) + V(1)) / 2.0) pools, and a shorter list than the input reduces dimensionality.

Build an output vector from expressions in order, varargs form.

Reduce the whole feature vector to one scalar with op.

The vector-consuming half of the AST, and the only Kotlin-side consumer of VFoldOp.