test(engine): RED — RSI-class blueprint needs the absent std vocabulary ops
Executable spec for the by-chance vocabulary gaps: an RSI-like gain/loss-split-and-ratio composition authored purely as blueprint data (Const/Div/Abs/Max/Min) must load through std_vocabulary, build, and run to hand-computed RS values (2.0 at t3, 3.0 at t4 over 10,12,11,14). Fails with UnknownNodeType(Const) — feature absent. Const is unary with an f64 'value' param (clock input, value ignored) mirroring EqConst's constant-as-param pattern; Div/Max/Min binary mirroring Add/Sub; Abs unary mirroring Sqrt; Div follows IEEE-754. refs #236
This commit is contained in:
@@ -0,0 +1,123 @@
|
||||
//! Acceptance proof for issue #236: an **RSI-class** signal — the classic
|
||||
//! gain/loss split of the price change and the smoothed **ratio** of average gain
|
||||
//! to average loss — composes *purely from blueprint data* through the injected
|
||||
//! `aura_std::std_vocabulary` and runs to hand-computable RS values. This is the
|
||||
//! property that pins the four std-vocabulary gaps the issue names as a single
|
||||
//! honest behaviour: `Div`, a `Const` source, `Abs`, and pairwise `Max`/`Min`.
|
||||
//!
|
||||
//! The composition is authored as a JSON document (never as Rust node identifiers),
|
||||
//! so the file compiles regardless of whether the new node types exist yet: it is
|
||||
//! RED because `std_vocabulary` does not resolve the new type ids (the public loader
|
||||
//! returns `LoadError::UnknownNodeType("Const")` for the first absent one), and GREEN
|
||||
//! only once all five are rostered AND behave correctly. It exercises the same public
|
||||
//! seam a World / project `cdylib` uses (`blueprint_from_json` + an injected
|
||||
//! vocabulary — C24), mirroring `blueprint_serde_e2e.rs`; the recording sink is added
|
||||
//! in Rust because a sink is deliberately outside the #155 std vocabulary.
|
||||
//!
|
||||
//! Contract the GREEN implementation must satisfy (the type ids a blueprint writes
|
||||
//! and the one new param name — bound params re-apply by name on load):
|
||||
//! - type ids: `"Const"`, `"Div"`, `"Abs"`, `"Max"`, `"Min"`
|
||||
//! - `Const` is unary (one clock input, value ignored) with an f64 param `"value"`
|
||||
//! - `Max`/`Min`/`Div` are binary (slots 0,1); `Abs` is unary (slot 0)
|
||||
|
||||
use std::sync::mpsc;
|
||||
|
||||
use aura_core::{Firing, Scalar, ScalarKind, Timestamp};
|
||||
use aura_engine::{blueprint_from_json, BlueprintNode, Composite, Edge, Role, Target, VecSource};
|
||||
use aura_std::{std_vocabulary, Recorder};
|
||||
|
||||
// The RSI-class signal as blueprint data. Raw price fans out to a zero `Const`
|
||||
// (its clock is the price role), a `Delay[1]`, and a `Sub`; `delta = price - prev`
|
||||
// splits into `gain = Max(delta, 0)` and `loss = Abs(Min(delta, 0))`; each is
|
||||
// smoothed by `SMA(2)`; `rs = Div(avg_gain, avg_loss)` is the single output. All
|
||||
// params are bound, so the blueprint has an empty open-param space. The recording
|
||||
// sink is NOT here (sinks are outside the std vocabulary — added in Rust below).
|
||||
//
|
||||
// Node indices: 0 Const · 1 Delay · 2 Sub · 3 Max · 4 Min · 5 Abs ·
|
||||
// 6 SMA(avg_gain) · 7 SMA(avg_loss) · 8 Div.
|
||||
const RSI_BLUEPRINT_JSON: &str = r#"{
|
||||
"format_version": 1,
|
||||
"blueprint": {
|
||||
"name": "rsi_signal",
|
||||
"nodes": [
|
||||
{"primitive":{"type":"Const","bound":[{"pos":0,"name":"value","kind":"F64","value":{"F64":0.0}}]}},
|
||||
{"primitive":{"type":"Delay","bound":[{"pos":0,"name":"lag","kind":"I64","value":{"I64":1}}]}},
|
||||
{"primitive":{"type":"Sub"}},
|
||||
{"primitive":{"type":"Max"}},
|
||||
{"primitive":{"type":"Min"}},
|
||||
{"primitive":{"type":"Abs"}},
|
||||
{"primitive":{"type":"SMA","name":"avg_gain","bound":[{"pos":0,"name":"length","kind":"I64","value":{"I64":2}}]}},
|
||||
{"primitive":{"type":"SMA","name":"avg_loss","bound":[{"pos":0,"name":"length","kind":"I64","value":{"I64":2}}]}},
|
||||
{"primitive":{"type":"Div"}}
|
||||
],
|
||||
"edges": [
|
||||
{"from":1,"to":2,"slot":1,"from_field":0},
|
||||
{"from":2,"to":3,"slot":0,"from_field":0},
|
||||
{"from":0,"to":3,"slot":1,"from_field":0},
|
||||
{"from":2,"to":4,"slot":0,"from_field":0},
|
||||
{"from":0,"to":4,"slot":1,"from_field":0},
|
||||
{"from":4,"to":5,"slot":0,"from_field":0},
|
||||
{"from":3,"to":6,"slot":0,"from_field":0},
|
||||
{"from":5,"to":7,"slot":0,"from_field":0},
|
||||
{"from":6,"to":8,"slot":0,"from_field":0},
|
||||
{"from":7,"to":8,"slot":1,"from_field":0}
|
||||
],
|
||||
"input_roles": [
|
||||
{"name":"price","targets":[{"node":0,"slot":0},{"node":1,"slot":0},{"node":2,"slot":0}]}
|
||||
],
|
||||
"output": [{"node":8,"field":0,"name":"rs"}]
|
||||
}
|
||||
}"#;
|
||||
|
||||
// Nest the loaded RSI signal under a Rust-built root that records its single `rs`
|
||||
// output, feed the price fixture through the public `VecSource`, and collect the
|
||||
// recorded `(ts, [rs])` trace — the only observable behaviour asserted on.
|
||||
fn run_recording(signal: Composite, prices: Vec<(Timestamp, Scalar)>) -> Vec<(Timestamp, Vec<Scalar>)> {
|
||||
let (tx, rx) = mpsc::channel();
|
||||
let root = Composite::new(
|
||||
"h",
|
||||
vec![
|
||||
BlueprintNode::Composite(signal),
|
||||
Recorder::builder(vec![ScalarKind::F64], Firing::Any, tx).into(),
|
||||
],
|
||||
vec![Edge { from: 0, to: 1, slot: 0, from_field: 0 }], // rs -> recorder col[0]
|
||||
vec![Role {
|
||||
name: "src".into(),
|
||||
targets: vec![Target { node: 0, slot: 0 }], // price -> nested signal's price role
|
||||
source: Some(ScalarKind::F64),
|
||||
}],
|
||||
vec![],
|
||||
);
|
||||
let mut h = root.bootstrap_with_params(vec![]).expect("bootstraps (no open params)");
|
||||
h.run(vec![Box::new(VecSource::new(prices))]);
|
||||
rx.try_iter().collect()
|
||||
}
|
||||
|
||||
/// The RSI-class gain/loss-split-and-ratio composes from blueprint data through the
|
||||
/// std vocabulary and runs to the hand-computed RS sequence. Prices `[10,12,11,14]`
|
||||
/// give deltas `[+2,-1,+3]`, so gains `[2,0,3]` and losses `[0,1,0]`; SMA(2) of each
|
||||
/// warms up on the first delta and then yields RS = avg_gain/avg_loss = 1.0/0.5 = 2.0
|
||||
/// at t3 and 1.5/0.5 = 3.0 at t4. Every new operator is load-bearing to these two
|
||||
/// numbers: `Max` picks the positive part, `Min`+`Abs` the loss magnitude, `Const`
|
||||
/// the zero threshold, `Div` the ratio.
|
||||
#[test]
|
||||
fn rsi_composes_from_blueprint_data_and_yields_hand_computed_rs() {
|
||||
let signal =
|
||||
blueprint_from_json(RSI_BLUEPRINT_JSON, &|t| std_vocabulary(t)).expect("loads through the std vocabulary");
|
||||
|
||||
let prices: Vec<(Timestamp, Scalar)> = [(1_i64, 10.0_f64), (2, 12.0), (3, 11.0), (4, 14.0)]
|
||||
.iter()
|
||||
.map(|&(t, p)| (Timestamp(t), Scalar::f64(p)))
|
||||
.collect();
|
||||
|
||||
let trace = run_recording(signal, prices);
|
||||
|
||||
assert_eq!(
|
||||
trace,
|
||||
vec![
|
||||
(Timestamp(3), vec![Scalar::f64(2.0)]),
|
||||
(Timestamp(4), vec![Scalar::f64(3.0)]),
|
||||
],
|
||||
"RSI gain/loss-split-and-ratio must emit RS = 2.0 at t3 and 3.0 at t4; got {trace:?}",
|
||||
);
|
||||
}
|
||||
Reference in New Issue
Block a user