Brummel
3b49074156
Realizes the C10 reframe (cycle 0007): the strategy DAG's output is an
intent/exposure stream, and a sim-optimal broker integrates it into a synthetic
pip-equity curve that measures SIGNAL QUALITY — the project's first trading
result, and its primary research loop.
Two new aura-std nodes (plain structs; the engine stays domain-free):
- Exposure { scale }: the decision/sizing node — clamp(signal/scale, -1, +1),
one f64 exposure per fired cycle, None until warmed up. Sizing/risk live in
`scale`.
- SimBroker { pip_size }: class (a) of C10 — consumes exposure (slot 0) + price
(slot 1), integrates the return earned by the exposure HELD INTO each cycle
(prev_exposure, decided at t-1) so it is causal / look-ahead-free (C2), and
emits cumulative pips. pip_size is held reference metadata (C7/C15), never
streamed.
End-to-end proof in the aura-engine harness test module (it dev-depends on
aura-std): a SMA(2)-SMA(4) cross -> Exposure -> SimBroker -> Recorder sink wires
a full signal-quality backtest; the recorded equity matches a hand-computed pip
curve ([0,0,0,0, 0.035]) and is bit-identical across two runs (C1). The engine
itself is unchanged — pure node authoring on the frozen substrate.
Verified: cargo test --workspace green (20 core + 30 engine + 9 std; 8 new);
clippy --all-targets -D warnings clean; engine/core surface-purity grep (no
dyn Any/Rc/RefCell) clean.
Note: the plan inlined `Window::first()`, which aura-core's Window does not
expose; the shipped code uses the semantically identical `Window::get(0)`
(newest value, or 0.0 when the exposure leg is cold).
closes #4
closes #5
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
74 lines
2.5 KiB
Rust
74 lines
2.5 KiB
Rust
//! `Exposure` — shapes a raw signal score into a bounded exposure (intent).
|
|
//! The decision/sizing node of C10's chain `signals -> decision/sizing node ->
|
|
//! exposure stream`: one f64 input, one f64 output `clamp(signal / scale, -1, +1)`.
|
|
//! `scale` sets which signal magnitude maps to full exposure (sizing lives here).
|
|
|
|
use aura_core::{Ctx, FieldSpec, Firing, InputSpec, Node, NodeSchema, Scalar, ScalarKind};
|
|
|
|
/// Bounded exposure from a raw signal score: `clamp(signal / scale, -1.0, +1.0)`.
|
|
/// Emits `None` until its input is present (warm-up filter, C8).
|
|
pub struct Exposure {
|
|
scale: f64,
|
|
out: [Scalar; 1],
|
|
}
|
|
|
|
impl Exposure {
|
|
/// Build an exposure node with saturation magnitude `scale` (must be > 0).
|
|
pub fn new(scale: f64) -> Self {
|
|
assert!(scale > 0.0, "Exposure scale must be > 0");
|
|
Self { scale, out: [Scalar::F64(0.0)] }
|
|
}
|
|
}
|
|
|
|
impl Node for Exposure {
|
|
fn schema(&self) -> NodeSchema {
|
|
NodeSchema {
|
|
inputs: vec![InputSpec { kind: ScalarKind::F64, lookback: 1, firing: Firing::Any }],
|
|
output: vec![FieldSpec { name: "exposure", kind: ScalarKind::F64 }],
|
|
}
|
|
}
|
|
|
|
fn eval(&mut self, ctx: Ctx<'_>) -> Option<&[Scalar]> {
|
|
let w = ctx.f64_in(0);
|
|
if w.is_empty() {
|
|
return None; // not yet warmed up (C8 filter)
|
|
}
|
|
self.out[0] = Scalar::F64((w[0] / self.scale).clamp(-1.0, 1.0));
|
|
Some(&self.out)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use aura_core::{AnyColumn, Timestamp};
|
|
|
|
#[test]
|
|
fn exposure_clamps_to_unit_band() {
|
|
let mut e = Exposure::new(0.5);
|
|
let mut inputs = vec![AnyColumn::with_capacity(ScalarKind::F64, 1)];
|
|
// (raw signal, expected clamped exposure) for scale 0.5
|
|
let cases = [
|
|
(0.1_f64, 0.2_f64), // within band
|
|
(0.5, 1.0), // at the high edge
|
|
(1.0, 1.0), // saturates high
|
|
(-0.1, -0.2), // within band, negative
|
|
(-1.0, -1.0), // saturates low
|
|
];
|
|
for (sig, want) in cases {
|
|
inputs[0].push(Scalar::F64(sig)).unwrap();
|
|
assert_eq!(
|
|
e.eval(Ctx::new(&inputs, Timestamp(0))),
|
|
Some([Scalar::F64(want)].as_slice())
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn exposure_is_none_until_input_present() {
|
|
let mut e = Exposure::new(0.5);
|
|
let inputs = vec![AnyColumn::with_capacity(ScalarKind::F64, 1)];
|
|
assert_eq!(e.eval(Ctx::new(&inputs, Timestamp(0))), None);
|
|
}
|
|
}
|