Enum Expr 

pub enum Expr {
    Literal(AnyValue<'static>),
    Selector(SelectExpr),
    Aggregate(AggExpr),
    Schedule(ScheduleExpr),
    Binary(BinaryExpr),
    Unary(UnaryExpr),
    Trinary(TrinaryExpr),
}

Variants

Literal(AnyValue<'static>)

Selector(SelectExpr)

Aggregate(AggExpr)

Schedule(ScheduleExpr)

Binary(BinaryExpr)

Unary(UnaryExpr)

Trinary(TrinaryExpr)

Implementations

impl Expr

pub fn time(self) -> Expr

pub fn value(self) -> Expr

pub fn debug(self) -> Expr

pub fn rolling(self, window_size: usize) -> Expr

pub fn first(self) -> Expr

pub fn last(self) -> Expr

pub fn sum(self) -> Expr

pub fn mean(self) -> Expr

pub fn stddev(self) -> Expr

pub fn min(self) -> Expr

pub fn max(self) -> Expr

pub fn var(self) -> Expr

pub fn skew(self) -> Expr

pub fn count(self) -> Expr

pub fn slope(self) -> Expr

pub fn unique(self) -> Expr

pub fn pow(self, exp: impl Into<Expr>) -> Expr

pub fn lt(self, rhs: impl Into<Expr>) -> Expr

pub fn lte(self, rhs: impl Into<Expr>) -> Expr

pub fn gt(self, rhs: impl Into<Expr>) -> Expr

pub fn gte(self, rhs: impl Into<Expr>) -> Expr

pub fn eq(self, rhs: impl Into<Expr>) -> Expr

pub fn ne(self, rhs: impl Into<Expr>) -> Expr

pub fn between(self, low: impl Into<Expr>, high: impl Into<Expr>) -> Expr

pub fn and(self, rhs: impl Into<Expr>) -> Expr

pub fn or(self, rhs: impl Into<Expr>) -> Expr

pub fn not(self) -> Expr

pub fn neg(self) -> Expr

pub fn abs(self) -> Expr

pub fn add(self, rhs: impl Into<Expr>) -> Expr

pub fn sub(self, rhs: impl Into<Expr>) -> Expr

pub fn mul(self, rhs: impl Into<Expr>) -> Expr

pub fn div(self, rhs: impl Into<Expr>) -> Expr

pub fn clamp(self, min: impl Into<Expr>, max: impl Into<Expr>) -> Expr

pub fn or_else(self, rhs: impl Into<Expr>) -> Expr

Returns self if it evaluates to a finite number, otherwise rhs. Triggers fallback on Null, NaN, and ±Inf. Short-circuits — rhs is only evaluated when needed, so it’s safe to use as a non-trivial default.

pub fn min_with(self, rhs: impl Into<Expr>) -> Expr

Elementwise min: min(self, rhs). NaN on one side returns the other. Use as a ceiling: expr.min_with(2.0).

pub fn max_with(self, rhs: impl Into<Expr>) -> Expr

Elementwise max: max(self, rhs). NaN on one side returns the other. Use as a floor: expr.max_with(0.05).

pub fn quantile(self, q: f32) -> Expr

Quantile at q ∈ [0, 1] via linear interpolation between adjacent ranks. On an empty buffer returns 0.0. Filters non-finite samples before sorting. O(n log n) per evaluation — fine for window sizes ≤ ~1000.

pub fn stagnation(self, epsilon: f32) -> Expr

pub fn cast(self, to: DataType) -> Expr

pub fn error(self, target: f32) -> Expr

Relative error from a target: (self - target) / target. Fuses into a single Affine node. target == 0 produces a degenerate expression (division by zero shows up as a NaN/Inf at eval time, then propagates to the outer Clamp).

impl Expr

pub fn compile(self) -> Expr

Walks the tree bottom-up and rewrites algebraically equivalent shapes into the smallest possible form. Specifically:

• Pure-literal subtrees fold (Lit(2) + Lit(3) → Lit(5))
• Add / Sub / Mul / Div with one literal operand fuses into a Unary(Affine) (x * 5 + 3 → Affine { scale: 5, bias: 3 })
• Nested affines collapse: s2 * (s1*x + b1) + b2 → Affine(s2*s1, s2*b1 + b2)

Called automatically when wrapping in Rate::Expr or NamedExpr. Safe to call multiple times — idempotent. Mathematically lossless within f32 precision (and within the existing arithmetic semantics for Null / non-finite operands).

impl Expr

pub fn reset(&mut self)

Recursively clears state in stateful operators: rolling-window buffers in Aggregate/Buffer nodes and counters in Schedule::Every. Children of binary/unary/trinary nodes are also visited. Leaf nodes (literals, selectors) are unaffected.

Use after an engine restart or whenever the controller should “forget” accumulated history.

pub fn lit(value: impl Into<AnyValue<'static>>) -> Expr

pub fn select(name: impl Into<SmallStr>) -> Expr

pub fn when(cond: impl Into<Expr>) -> When

pub fn every(interval: usize) -> When

pub fn identity() -> Expr

Trait Implementations

impl<T> Add<T> for Expr

where T: Into<Expr>,

type Output = Expr

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Expr

Performs the + operation.

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Expr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Div<T> for Expr

where T: Into<Expr>,

type Output = Expr

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Expr

Performs the / operation.

impl<T> Evaluate<T> for Expr

where T: ExprSelector,

fn eval<'a>(&'a mut self, metrics: &T) -> Result<AnyValue<'a>, RadiateError>

impl From<Expr> for Rate

fn from(expr: Expr) -> Self

Converts to this type from the input type.

impl From<String> for Expr

fn from(value: String) -> Self

Converts to this type from the input type.

impl From<bool> for Expr

fn from(value: bool) -> Self

Converts to this type from the input type.

impl From<char> for Expr

fn from(value: char) -> Self

Converts to this type from the input type.

impl From<f32> for Expr

fn from(value: f32) -> Self

Converts to this type from the input type.

impl From<f64> for Expr

fn from(value: f64) -> Self

Converts to this type from the input type.

impl From<i8> for Expr

fn from(value: i8) -> Self

Converts to this type from the input type.

impl From<i16> for Expr

fn from(value: i16) -> Self

Converts to this type from the input type.

impl From<i32> for Expr

fn from(value: i32) -> Self

Converts to this type from the input type.

impl From<i64> for Expr

fn from(value: i64) -> Self

Converts to this type from the input type.

impl From<i128> for Expr

fn from(value: i128) -> Self

Converts to this type from the input type.

impl From<u8> for Expr

fn from(value: u8) -> Self

Converts to this type from the input type.

impl From<u16> for Expr

fn from(value: u16) -> Self

Converts to this type from the input type.

impl From<u32> for Expr

fn from(value: u32) -> Self

Converts to this type from the input type.

impl From<u64> for Expr

fn from(value: u64) -> Self

Converts to this type from the input type.

impl From<u128> for Expr

fn from(value: u128) -> Self

Converts to this type from the input type.

impl<T> Mul<T> for Expr

where T: Into<Expr>,

type Output = Expr

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Expr

Performs the * operation.

impl Neg for Expr

type Output = Expr

The resulting type after applying the - operator.

fn neg(self) -> Expr

Performs the unary - operation.

impl Not for Expr

type Output = Expr

The resulting type after applying the ! operator.

fn not(self) -> Expr

Performs the unary ! operation.

impl PartialEq for Expr

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Expr

impl<T> Sub<T> for Expr

where T: Into<Expr>,

type Output = Expr

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Expr

Performs the - operation.