claude
09994b83ed
The three C8 sinks realizing the per-tap subscription model (#283): TapFold (closed FoldKind vocabulary Count|Sum|Mean|Min|Max|First|Last, in-graph accumulation, exactly one finalize row), TapRecorder (bounded SyncSender<(Timestamp, Cell)>, lossless backpressure — a full channel blocks the sim, wall time never state), and TapLive (consumer-owned closure, inline on the sim thread). All three move (Timestamp, Cell) — 16 B, Copy — instead of (Timestamp, Vec<Scalar>): zero per-cycle heap on the tap path (#77 part 2). The shared kind-dispatched newest-cell read lives in tap_cell.rs. Known-good subset commit of iter tap-subscribers (tasks 1-3 of 7, each gated implementer -> spec-compliance -> quality DONE; the loop blocked on a task-4 plan defect, repaired separately): the trace-store streaming writer, the TapPlan wiring seam, and both entry-point rewires follow in this same cycle. Verified directly: cargo test -p aura-std — 109 passed, 0 failed. refs #283, refs #77
81 lines
2.1 KiB
Rust
81 lines
2.1 KiB
Rust
//! `aura-std` — the standard node library shipped with the engine.
|
|
//!
|
|
//! The universal, batteries-included building blocks every project gets for
|
|
//! free: common indicators (SMA, ATR, RSI, …), resamplers, the `SessionNode`,
|
|
//! standard combinators, the legacy `SimBroker` pip yardstick, and cost-model
|
|
//! nodes authored against the [`CostNode`] trait + [`CostRunner`] adapter
|
|
//! (`ConstantCost`, `VolSlippageCost`, …, in R — C10). Depends only on `aura-core`
|
|
//! (the shared contract).
|
|
//!
|
|
//! This is the top tier of the three-tier node-reuse model (contract C16):
|
|
//!
|
|
//! - `aura-std` — universal blocks, here, ship with the engine;
|
|
//! - shared node crates — cross-project-reusable blocks, in their own repos,
|
|
//! pulled in as cargo git dependencies;
|
|
//! - project-local `nodes/` — experimental, project-specific blocks.
|
|
//!
|
|
//! The first block lands with the walking skeleton: [`Sma`], the simple moving
|
|
//! average — a worked producer node proving the `aura-core` `Node` contract.
|
|
|
|
mod abs;
|
|
mod add;
|
|
mod and;
|
|
mod const_node;
|
|
mod cumsum;
|
|
mod delay;
|
|
mod div;
|
|
mod ema;
|
|
mod eqconst;
|
|
mod gated_recorder;
|
|
mod gt;
|
|
mod latch;
|
|
mod lincomb;
|
|
mod max;
|
|
mod min;
|
|
mod mul;
|
|
mod recorder;
|
|
mod rolling_max;
|
|
mod rolling_min;
|
|
mod scale;
|
|
mod select;
|
|
mod series_reducer;
|
|
mod sign;
|
|
mod sma;
|
|
mod sqrt;
|
|
mod sub;
|
|
mod tap_cell;
|
|
mod tap_fold;
|
|
mod tap_live;
|
|
mod tap_recorder;
|
|
mod when;
|
|
pub use abs::Abs;
|
|
pub use add::Add;
|
|
pub use and::And;
|
|
pub use const_node::Const;
|
|
pub use cumsum::CumSum;
|
|
pub use delay::Delay;
|
|
pub use div::Div;
|
|
pub use ema::Ema;
|
|
pub use eqconst::EqConst;
|
|
pub use gated_recorder::GatedRecorder;
|
|
pub use gt::Gt;
|
|
pub use latch::Latch;
|
|
pub use lincomb::LinComb;
|
|
pub use max::Max;
|
|
pub use min::Min;
|
|
pub use mul::Mul;
|
|
pub use recorder::Recorder;
|
|
pub use rolling_max::RollingMax;
|
|
pub use rolling_min::RollingMin;
|
|
pub use scale::Scale;
|
|
pub use select::Select;
|
|
pub use series_reducer::SeriesReducer;
|
|
pub use sign::Sign;
|
|
pub use sma::Sma;
|
|
pub use sqrt::Sqrt;
|
|
pub use sub::Sub;
|
|
pub use tap_fold::{fold_binds_at, fold_output_kind, FoldKind, TapFold};
|
|
pub use tap_live::TapLive;
|
|
pub use tap_recorder::TapRecorder;
|
|
pub use when::When;
|