claude
a32dc38d18
C29 compile/unit seam, task 3 of the self-description plan: every aura-std NodeSchema literal threads its one-line doc. Four texts were corrected against the actual eval/finalize semantics rather than taken from the plan table verbatim: Delay is a lag-N register (not one-step), GatedRecorder flushes an ungated final row at finalize, Latch is a level-sensitive set/reset register (captures no input), SeriesReducer emits its single summary row at finalize (not per cycle). Gate: cargo build -p aura-std --lib clean; full std test run follows at the all-crates gate once strategy/backtest/engine thread their sites (the earlier per-crate test gate was unsatisfiable in isolation -- std's dev-deps pull crates whose sites belong to later tasks). refs #316
115 lines
3.7 KiB
Rust
115 lines
3.7 KiB
Rust
//! `Sign` — a stateless `f64 -> f64` sign extractor emitting exactly `+1.0`,
|
|
//! `-1.0`, or `0.0` by strict comparison.
|
|
//!
|
|
//! The `sign0()` semantics already private in
|
|
//! [`PositionManagement`](crate::PositionManagement)
|
|
//! (`position_management.rs`), promoted to vocabulary (#281): `> 0 -> +1.0`,
|
|
//! `< 0 -> -1.0`, else `0.0` — so `NaN` (which compares false on both sides)
|
|
//! and `-0.0` both fall to `0.0`. The private helper itself stays untouched;
|
|
//! this cell is the roster-eligible twin, the generic bridge the Bool/F64
|
|
//! conditional plane was missing.
|
|
//!
|
|
//! One `f64` input (`Firing::Any`), one `f64` output, no params, stateless,
|
|
//! allocation-free on the hot path (the single-cell output buffer is sized
|
|
//! once at construction, C7).
|
|
|
|
use aura_core::{Cell, Ctx, FieldSpec, Firing, Node, NodeSchema, PortSpec, PrimitiveBuilder, ScalarKind};
|
|
|
|
/// Stateless sign extractor: `+1.0` / `-1.0` / `0.0` by strict comparison
|
|
/// (`NaN` falls to `0.0`). Emits `None` until the input is warm (C8).
|
|
pub struct Sign {
|
|
out: [Cell; 1],
|
|
}
|
|
|
|
impl Sign {
|
|
/// Build a `Sign` node.
|
|
pub fn new() -> Self {
|
|
Self { out: [Cell::from_f64(0.0)] }
|
|
}
|
|
|
|
/// The param-generic recipe for a blueprint primitive: paramless, builds
|
|
/// through `Sign::new`.
|
|
pub fn builder() -> PrimitiveBuilder {
|
|
PrimitiveBuilder::new(
|
|
"Sign",
|
|
NodeSchema {
|
|
inputs: vec![PortSpec { kind: ScalarKind::F64, firing: Firing::Any, name: "value".into() }],
|
|
output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
|
|
params: vec![],
|
|
doc: "sign of the input: -1, 0 or +1",
|
|
},
|
|
|_| Box::new(Sign::new()),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl Default for Sign {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl Node for Sign {
|
|
fn lookbacks(&self) -> Vec<usize> {
|
|
vec![1]
|
|
}
|
|
|
|
fn eval(&mut self, ctx: Ctx<'_>) -> Option<&[Cell]> {
|
|
let v = ctx.f64_in(0);
|
|
if v.is_empty() {
|
|
return None; // warm-up gate (C8)
|
|
}
|
|
let x = v[0];
|
|
// strict comparisons: NaN and -0.0 both fall to 0.0, as sign0 does
|
|
let s = if x > 0.0 {
|
|
1.0
|
|
} else if x < 0.0 {
|
|
-1.0
|
|
} else {
|
|
0.0
|
|
};
|
|
self.out[0] = Cell::from_f64(s);
|
|
Some(&self.out)
|
|
}
|
|
|
|
fn label(&self) -> String {
|
|
"Sign".to_string()
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use aura_core::{AnyColumn, Scalar, Timestamp};
|
|
|
|
#[test]
|
|
fn sign_maps_the_three_regions_and_nan_to_zero() {
|
|
// PROPERTY: out = +1.0 / -1.0 / 0.0 by strict comparison — the sign0()
|
|
// semantics promoted to vocabulary. NaN compares false on both sides,
|
|
// so it falls to 0.0, exactly as sign0 does; -0.0 likewise.
|
|
let mut node = Sign::new();
|
|
let mut inputs = vec![AnyColumn::with_capacity(ScalarKind::F64, 1)];
|
|
let cases = [(2.5, 1.0), (-0.1, -1.0), (0.0, 0.0), (f64::NAN, 0.0), (-0.0, 0.0)];
|
|
for (x, want) in cases {
|
|
inputs[0].push(Scalar::f64(x)).unwrap();
|
|
let got = node.eval(Ctx::new(&inputs, Timestamp(0)));
|
|
assert_eq!(got, Some([Cell::from_f64(want)].as_slice()), "sign({x})");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn sign_is_none_until_warm() {
|
|
// Cold input -> None (C8 warm-up gate), like every std cell.
|
|
let mut node = Sign::new();
|
|
let inputs = vec![AnyColumn::with_capacity(ScalarKind::F64, 1)];
|
|
assert_eq!(node.eval(Ctx::new(&inputs, Timestamp(0))), None);
|
|
}
|
|
|
|
#[test]
|
|
fn input_slot_is_named_value() {
|
|
let names: Vec<String> =
|
|
Sign::builder().schema().inputs.iter().map(|p| p.name.clone()).collect();
|
|
assert_eq!(names, ["value"]);
|
|
}
|
|
}
|