Brummel
82635fa259
Motivation ---------- The C7 realization note (cd3d1ca/049f22a) deferred this step: with Scalar split into { kind, cell }, the tag-free Cell could become the hot-path carrier, but eval and the edges still flowed the fatter self-describing Scalar. This lands the swap. Change ------ - Node::eval now returns Option<&[Cell]>; every node out-buffer is [Cell; N]. The inter-node forward copies the row into a Vec<Cell> and pushes each field via a new branch-free, infallible AnyColumn::push_cell — the edge from_field->slot kind match is verified once at bootstrap (C7), so the runtime push needs no per-value kind check. It only removes a Result the forward path already .expect()ed. - Scalar stays on the self-describing dynamic boundaries: the param plane (build / bind / compile_with_params / sweep points / RunManifest), AnyColumn::get (the type-erased read for sinks / serde), and source ingestion (Source::next, the heterogeneous C3 merge). The fallible AnyColumn::push is retained for ingestion + the kind-guard tests. Trade ----- The per-value runtime kind check on node OUTPUT is removed: a node that builds a wrong-kind cell pushes raw bits with no panic. This is the same authoring-bug class C8 already leaves to a debug_assert (output width); node-output-kind correctness is the node's declared FieldSpec contract, caught by each node's own eval test. Cross-node kind agreement still rests on the bootstrap kind-check (bootstrap_rejects_*_kind_mismatch, green). Tests ----- Behaviour-preserving (C1): 285 green, 0 red. The only test-expectation edits are carrier re-spellings (Scalar::f64(x) -> Cell::from_f64(x)) of identical values; test column writes and out-of-graph channel rows stay Scalar (the spec's three-role rule). Adds an AnyColumn::push_cell round-trip test plus a cross-kind end-to-end forward test (a mixed f64/i64 record whose bit patterns diverge across kinds — pins the i64 forward path the f64-only tests cannot catch). Ledger C7/C8 notes updated. Gates: cargo build / test / clippy --all-targets -D warnings / doc --workspace all clean. closes #74
93 lines
2.7 KiB
Rust
93 lines
2.7 KiB
Rust
//! `Sub` — two-input f64 difference (input 0 minus input 1), e.g. a fast/slow
|
|
//! spread. The walking skeleton's second worked node: it gives the sim loop a
|
|
//! real fan-out + join to run (two SMAs joining into one node), exercising
|
|
//! multi-input `Ctx` access inside a running graph.
|
|
|
|
use aura_core::{Cell, Ctx, FieldSpec, Firing, Node, NodeSchema, PortSpec, PrimitiveBuilder, ScalarKind};
|
|
|
|
/// Two-input f64 difference: input 0 minus input 1. Emits `None` until both
|
|
/// inputs have a value.
|
|
pub struct Sub {
|
|
out: [Cell; 1],
|
|
}
|
|
|
|
impl Sub {
|
|
/// Build a `Sub` node.
|
|
pub fn new() -> Self {
|
|
Self { out: [Cell::from_f64(0.0)] }
|
|
}
|
|
|
|
/// The param-generic recipe for a blueprint primitive: paramless, builds through
|
|
/// `Sub::new`.
|
|
pub fn builder() -> PrimitiveBuilder {
|
|
PrimitiveBuilder::new(
|
|
"Sub",
|
|
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(Sub::new()),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl Default for Sub {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl Node for Sub {
|
|
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] - b[0]);
|
|
Some(&self.out)
|
|
}
|
|
|
|
fn label(&self) -> String {
|
|
"Sub".to_string()
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use aura_core::{AnyColumn, Scalar, Timestamp};
|
|
|
|
#[test]
|
|
fn sub_is_difference_once_both_inputs_present() {
|
|
let mut sub = Sub::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(10.0)).unwrap();
|
|
assert_eq!(sub.eval(Ctx::new(&inputs, Timestamp(0))), None);
|
|
|
|
// both present -> a - b
|
|
inputs[1].push(Scalar::f64(4.0)).unwrap();
|
|
assert_eq!(sub.eval(Ctx::new(&inputs, Timestamp(0))), Some([Cell::from_f64(6.0)].as_slice()));
|
|
}
|
|
|
|
#[test]
|
|
fn input_slots_are_named_lhs_rhs() {
|
|
let s = Sub::builder();
|
|
let names: Vec<&str> = s.schema().inputs.iter().map(|p| p.name.as_str()).collect();
|
|
assert_eq!(names, ["lhs", "rhs"]);
|
|
}
|
|
}
|