Brummel
1100a60c76
Replace the engine's single observe: usize recording affordance with recording-by-node, so one run records many streams. A recording node reads its typed input windows + ctx.now() in eval and pushes the record to a destination it holds as a field (a channel, a chart handle) — an out-of-graph side effect. There is no Sink type, trait, or engine flag: a pure-consumer node returns None, and a node may record AND return a forwarded output in the same eval (the C8 "both" case). In-graph routing stays engine-owned data (the edge table); the escape out of the graph is the node's own side effect, and that boundary is the determinism / graph-as-data boundary. Engine surface shrinks: Ctx gains now: Timestamp + now() (C2-causal, the present cycle's timestamp); Harness loses the observe field, its observe >= n bootstrap check, and the per-cycle observed-row collection; bootstrap drops its 4th param; run returns (). Recorded streams are now sparse and timestamped (a record per fired cycle) instead of the dense Vec<Option<row>>. The Ctx::new signature change touched 9 call sites across three crates (not the 3 the spec estimated) — aura-std's node tests and the engine run loop were threaded too. The engine test suite migrated to a test-local Recorder fixture whose read-back is an mpsc channel, never Rc/RefCell, keeping aura-engine/src purity-clean (C7). Eight new proof tests cover the multi-sink headline, producer-and-sink, mixed-kind recording, all-fields tap, both recorder firing modes, determinism, and recorder-edge kind rejection. C8/C22 gain cycle-0006 realization notes. Gates: workspace test 45 green (core 20, std 3, engine 22), clippy -D warnings clean, purity grep clean (only a comment names Rc/RefCell). closes #2
71 lines
2.0 KiB
Rust
71 lines
2.0 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::{Ctx, FieldSpec, Firing, InputSpec, Node, NodeSchema, Scalar, ScalarKind};
|
|
|
|
/// Two-input f64 difference: input 0 minus input 1. Emits `None` until both
|
|
/// inputs have a value.
|
|
pub struct Sub {
|
|
out: [Scalar; 1],
|
|
}
|
|
|
|
impl Sub {
|
|
/// Build a `Sub` node.
|
|
pub fn new() -> Self {
|
|
Self { out: [Scalar::F64(0.0)] }
|
|
}
|
|
}
|
|
|
|
impl Default for Sub {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl Node for Sub {
|
|
fn schema(&self) -> NodeSchema {
|
|
NodeSchema {
|
|
inputs: vec![
|
|
InputSpec { kind: ScalarKind::F64, lookback: 1, firing: Firing::Any },
|
|
InputSpec { kind: ScalarKind::F64, lookback: 1, firing: Firing::Any },
|
|
],
|
|
output: vec![FieldSpec { name: "value", kind: ScalarKind::F64 }],
|
|
}
|
|
}
|
|
|
|
fn eval(&mut self, ctx: Ctx<'_>) -> Option<&[Scalar]> {
|
|
let a = ctx.f64_in(0);
|
|
let b = ctx.f64_in(1);
|
|
if a.is_empty() || b.is_empty() {
|
|
return None;
|
|
}
|
|
self.out[0] = Scalar::F64(a[0] - b[0]);
|
|
Some(&self.out)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use aura_core::{AnyColumn, 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([Scalar::F64(6.0)].as_slice()));
|
|
}
|
|
}
|