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

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.

Strictly-greater-than comparison.

Strictly-greater-than against a literal.

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.

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.

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.

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.

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.