Brummel
99237e1d0a
Five new rostered node types (count-pin 23 -> 28, both the in-crate shape test and the cross-boundary CLI vocabulary e2e): Const is unary with an f64 'value' param — the clock input drives it, its value is ignored, since a zero-input node never evaluates in the total-push engine — mirroring EqConst's constant-as-param pattern; Div is binary IEEE-754 (x/0 -> signed inf, 0/0 -> NaN, unit-tested, no error channel); Abs unary mirroring Sqrt; Max/Min binary pairwise, distinct from the windowed RollingMax/RollingMin. Acceptance proof: the committed executable spec composes an RSI-class gain/loss-split-and-ratio signal purely from blueprint data through std_vocabulary and runs it to hand-computed RS values — the r_meanrev constant-folding workaround is no longer forced. Verified: headline test green, aura-std 163/0, full workspace suite green (independent mini-verify), clippy -D warnings clean. closes #236
89 lines
2.6 KiB
Rust
89 lines
2.6 KiB
Rust
//! `Max` — two-input f64 pairwise maximum (input 0 vs input 1), e.g. the
|
|
//! positive-part split of a price change: `gain = Max(delta, 0)`. Distinct
|
|
//! from `RollingMax`, which reduces a *window* of one input; `Max` combines
|
|
//! two co-present inputs, mirroring `Add`/`Sub`.
|
|
|
|
use aura_core::{Cell, Ctx, FieldSpec, Firing, Node, NodeSchema, PortSpec, PrimitiveBuilder, ScalarKind};
|
|
|
|
/// Two-input f64 pairwise maximum: `input 0 .max(input 1)`. Emits `None` until
|
|
/// both inputs have a value.
|
|
pub struct Max {
|
|
out: [Cell; 1],
|
|
}
|
|
|
|
impl Max {
|
|
pub fn new() -> Self {
|
|
Self { out: [Cell::from_f64(0.0)] }
|
|
}
|
|
|
|
pub fn builder() -> PrimitiveBuilder {
|
|
PrimitiveBuilder::new(
|
|
"Max",
|
|
NodeSchema {
|
|
inputs: vec![
|
|
PortSpec { kind: ScalarKind::F64, firing: Firing::Any, name: "lhs".into() },
|
|
PortSpec { kind: ScalarKind::F64, firing: Firing::Any, name: "rhs".into() },
|
|
],
|
|
output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
|
|
params: vec![],
|
|
},
|
|
|_| Box::new(Max::new()),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl Default for Max {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl Node for Max {
|
|
fn lookbacks(&self) -> Vec<usize> {
|
|
vec![1, 1]
|
|
}
|
|
|
|
fn eval(&mut self, ctx: Ctx<'_>) -> Option<&[Cell]> {
|
|
let a = ctx.f64_in(0);
|
|
let b = ctx.f64_in(1);
|
|
if a.is_empty() || b.is_empty() {
|
|
return None;
|
|
}
|
|
self.out[0] = Cell::from_f64(a[0].max(b[0]));
|
|
Some(&self.out)
|
|
}
|
|
|
|
fn label(&self) -> String {
|
|
"Max".to_string()
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use aura_core::{AnyColumn, Scalar, Timestamp};
|
|
|
|
#[test]
|
|
fn max_is_the_pairwise_larger_once_both_inputs_present() {
|
|
let mut m = Max::new();
|
|
let mut inputs = vec![
|
|
AnyColumn::with_capacity(ScalarKind::F64, 1),
|
|
AnyColumn::with_capacity(ScalarKind::F64, 1),
|
|
];
|
|
|
|
// only input 0 present -> None
|
|
inputs[0].push(Scalar::f64(2.0)).unwrap();
|
|
assert_eq!(m.eval(Ctx::new(&inputs, Timestamp(0))), None);
|
|
|
|
// both present -> max(a, b), either order
|
|
inputs[1].push(Scalar::f64(-1.0)).unwrap();
|
|
assert_eq!(m.eval(Ctx::new(&inputs, Timestamp(0))), Some([Cell::from_f64(2.0)].as_slice()));
|
|
}
|
|
|
|
#[test]
|
|
fn input_slots_are_named_lhs_rhs() {
|
|
let names: Vec<String> = Max::builder().schema().inputs.iter().map(|p| p.name.clone()).collect();
|
|
assert_eq!(names, ["lhs", "rhs"]);
|
|
}
|
|
}
|