portfolio_analyzer/

timing.rs

//! # Timing: should I own this for the long run, and when should I buy it?
//!
//! SD v2 is good at one thing: telling how *big* the next move will be
//! (chapter 3).  It is not good at calling direction over days or weeks
//! (chapters 2 and 8).  A long-term investor needs two different answers,
//! and this module gives both:
//!
//! 1. **Long-term probability of going up** ([`LongModel`]): the chance the
//!    stock closes higher in 126 bars (six months) or 252 bars (one year).
//!    Over a year, the market's upward drift is strong, so this probability
//!    is mostly drift, adjusted by trend, momentum, volatility and market
//!    weather.  `sd_timing research` measures how much of it is skill.
//! 2. **Short-term entry timing** ([`TimingModel::plan`]): for a stock you
//!    already want, where is it likely to trade *lower* in the next few
//!    weeks, how likely is it to get there, and is waiting worth the risk of
//!    missing the fill?  This is where SD's movement forecast pays: a stock
//!    whose SD expects a big move has a wider, deeper dip ahead than a calm
//!    one, and the limit price should sit further away.
//!
//! ## The entry-timing idea, from zero
//!
//! Suppose you will buy a stock within the next `N` trading days, no matter
//! what.  You can buy now at today's close `C`, or place a limit order at a
//! lower price `L` that is good for `N` days.  If price trades through `L`,
//! you pay `L`.  If it never does, you buy at the close on day `N`, which,
//! because stocks drift up, is usually *higher* than `C`.
//!
//! So the question is a trade-off: a deeper limit saves more when it fills,
//! but fills less often, and every miss costs you the drift.  We measure the
//! lowest low over the window in units of the stock's normal movement:
//!
//! ```text
//!   z_min = ln(lowest low over days t+1..t+N  ÷  C)  ÷  (σ · √N)
//! ```
//!
//! where `σ` is the 20-bar daily volatility.  Across 125 symbols and 25
//! years, the distribution of `z_min` depends on where SD's *intensity*
//! (the expected-move rank) and squeeze state sit: coiled stocks with a big
//! expected move dip further.  [`LowTable`] stores that distribution as 101
//! quantiles per (window, state, intensity decile) bucket.  Then:
//!
//! * **P(fill at L)** is the share of history in this bucket whose `z_min`
//!   reached `L`'s `z`.
//! * **The limit for certainty `c`** is the `c`-quantile of `z_min`: the
//!   deepest price that history reached at least `c` of the time.
//! * **The best plan** ([`EntryPlan`]) searches windows `≤ within` and
//!   certainties `≥ certainty` for the lowest *expected effective entry*:
//!   the average, over history, of "limit price if filled, day-`N` close if
//!   not".  If no plan beats buying now, the answer is "buy now".
//!
//! **Exit timing is the mirror image** ([`TimingModel::exit_plan`]): the
//! highest high over the window, `z_max`, sets sell limits, and the
//! six-month P(up) sets a "hold" or "sell" verdict ([`TimingConfig`]).
//! [`plan_for`] returns all of it for one stock in one call.
//!
//! Every table is learned from history and graded on later years it never
//! saw: see `docs/13-timing.md` and `reports/timing_*.txt`.

use crate::direction::{direction_frame, MarketWeather};
use crate::history::DatedBar;
use crate::indicators::OHLCV;
use crate::sd2::engine::Sd2Reading;
use crate::sd2::features::{FeatureConfig, FeatureFrame};
use crate::sd2::model::Logistic;
use serde::{Deserialize, Serialize};

/// Entry windows (trading days) with learned tables.
pub const WINDOWS: [usize; 5] = [5, 10, 21, 42, 63];
/// Long-term horizons (trading days): six months and one year.
pub const LONG_HORIZONS: [usize; 2] = [126, 252];
/// Certainty grid the planner searches.
pub const CERTAINTIES: [f64; 14] = [0.30, 0.35, 0.40, 0.45, 0.50, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95];
/// Squeeze states, in bucket order.
pub const STATES: [&str; 3] = ["coiled", "fired", "quiet"];
/// Limit orders are placed this far (0.1%) *above* the low history
/// reached, so a fill always means price traded through the order: merely
/// touching a price does not guarantee your order was reached in the queue.
pub const FILL_THROUGH: f64 = 0.001;

/// Squeeze state of a reading: 0 coiled, 1 fired (live), 2 quiet.
pub fn state_of(r: &Sd2Reading) -> usize {
    if r.is_active_fire {
        1
    } else if r.in_squeeze {
        0
    } else {
        2
    }
}

/// Bucket index: state × 10 + intensity decile.
pub fn bucket_of(r: &Sd2Reading) -> usize {
    state_of(r) * 10 + ((r.intensity * 10.0).floor() as usize).min(9)
}

/// The distribution of `z_min` (and what happened next) for one bucket.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct LowTable {
    /// 101 quantiles of `z_min`, from the 0th to the 100th percentile.
    pub quantiles: Vec<f64>,
    /// Median `z_min`: the typical lowest point of the window.
    pub median: f64,
    /// Median day of the low (for exit tables: of the high), as a fraction
    /// of the window (0..1).
    pub low_day: f64,
    /// Mean effective entry (exit tables: exit), as a log ratio to today's
    /// close, for each of [`CERTAINTIES`]: limit price if filled, day-`N`
    /// close if not.
    pub effective: Vec<f64>,
    /// Rows behind this table.
    pub n: usize,
}

impl LowTable {
    /// P(z_min ≤ z), interpolated from the stored quantiles.
    pub fn cdf(&self, z: f64) -> f64 {
        let q = &self.quantiles;
        if q.is_empty() {
            return f64::NAN;
        }
        if z < q[0] {
            return 0.0;
        }
        if z >= q[q.len() - 1] {
            return 1.0;
        }
        let k = q.partition_point(|&v| v <= z).max(1);
        let (a, b) = (q[k - 1], q[k]);
        let frac = if b > a { (z - a) / (b - a) } else { 0.0 };
        ((k - 1) as f64 + frac) / (q.len() - 1) as f64
    }

    /// The `c`-quantile of `z_min`: the limit, in z units, that history
    /// reached `c` of the time.
    pub fn quantile(&self, c: f64) -> f64 {
        let q = &self.quantiles;
        let x = c.clamp(0.0, 1.0) * (q.len() - 1) as f64;
        let k = (x.floor() as usize).min(q.len() - 2);
        q[k] + (x - k as f64) * (q[k + 1] - q[k])
    }
}

/// Long-term P(up) model over [`crate::direction::GROUPS`] columns.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LongModel {
    pub horizon: usize,
    /// Human-readable name of the feature groups used.
    pub groups: String,
    /// Column indices into a [`direction_frame`] row.
    pub cols: Vec<usize>,
    pub logistic: Logistic,
}

impl LongModel {
    pub fn p_up(&self, row: &[f64]) -> f64 {
        let x: Vec<f64> = self.cols.iter().map(|&c| row[c]).collect();
        if x.iter().any(|v| !v.is_finite()) {
            return crate::sd2::model::sigmoid(self.logistic.intercept);
        }
        self.logistic.predict(&x)
    }
}

/// Everything the timing indicator needs at run time.  Produced by
/// `sd_timing research` and embedded from `timing_model.json`.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TimingModel {
    /// One per [`LONG_HORIZONS`].
    pub long: Vec<LongModel>,
    pub windows: Vec<usize>,
    /// `tables[window][bucket]`, 30 buckets (3 states × 10 deciles).
    pub tables: Vec<Vec<LowTable>>,
    /// `unconditional[window]`: the same table ignoring SD (the fallback,
    /// and the baseline SD has to beat).
    pub unconditional: Vec<LowTable>,
    /// The exit mirror: quantiles of `z_max` (highest high), same layout.
    #[serde(default)]
    pub exit_tables: Vec<Vec<LowTable>>,
    #[serde(default)]
    pub exit_unconditional: Vec<LowTable>,
    /// Buckets with fewer rows than this fall back to `unconditional`.
    pub min_rows: usize,
    pub fitted_on: String,
}

/// A recommended way to buy one stock.
#[derive(Debug, Clone, Serialize)]
pub struct EntryPlan {
    pub close: f64,
    /// P(higher in 126 / 252 bars).
    pub p_up_126: f64,
    pub p_up_252: f64,
    /// `"skip"`, `"buy now"` or `"limit"`.  For `"limit"`, the fields below
    /// describe the best plan found; for `"buy now"` (and `"skip"`), the plan
    /// exactly as asked, so you can see what waiting would cost.
    pub action: &'static str,
    /// Window (trading days) and certainty of the chosen plan.
    pub window: usize,
    pub certainty: f64,
    /// Limit price and its distance below the close (0.03 = 3% lower).
    pub limit_price: f64,
    pub limit_discount: f64,
    /// Historical probability that price trades through the limit in time.
    pub p_fill: f64,
    /// Typical lowest price in the window (median of history's lows).
    pub typical_low: f64,
    /// Typical trading day of that low (1..window).
    pub typical_low_day: usize,
    /// Average effective entry vs buying now (−0.01 = 1% cheaper, +0.01 =
    /// 1% dearer), from history: limit if filled, day-`window` close if not.
    pub expected_saving: f64,
    pub bucket: String,
    pub reason: String,
}

/// What the person asked for.
#[derive(Debug, Clone, Copy)]
pub struct TimingAsk {
    /// Lowest acceptable fill probability (e.g. 0.7).
    pub certainty: f64,
    /// Longest wait, in trading days (e.g. 21).
    pub within: usize,
    /// Skip names whose one-year P(up) is below this.
    pub min_p_up: f64,
    /// A plan must save at least this much (log) to beat buying now.
    pub min_saving: f64,
}

impl Default for TimingAsk {
    fn default() -> Self {
        Self { certainty: 0.7, within: 21, min_p_up: 0.5, min_saving: 0.0025 }
    }
}

impl TimingModel {
    pub fn embedded() -> Self {
        serde_json::from_str(include_str!("timing_model.json")).expect("valid embedded timing_model.json")
    }

    /// The exit table for a window index and bucket (falls back when thin).
    pub fn exit_table(&self, w: usize, bucket: usize) -> &LowTable {
        let t = &self.exit_tables[w][bucket];
        if t.n >= self.min_rows { t } else { &self.exit_unconditional[w] }
    }

    /// The table for a window index and bucket (falls back when thin).
    pub fn table(&self, w: usize, bucket: usize) -> &LowTable {
        let t = &self.tables[w][bucket];
        if t.n >= self.min_rows { t } else { &self.unconditional[w] }
    }

    /// Long-term probabilities from a [`direction_frame`] row.
    pub fn long_p(&self, row: &[f64]) -> (f64, f64) {
        let p = |h: usize| self.long.iter().find(|m| m.horizon == h).map(|m| m.p_up(row)).unwrap_or(f64::NAN);
        (p(126), p(252))
    }

    /// Choose how to buy, given today's SD reading and long-term row.
    pub fn plan(&self, r: &Sd2Reading, long_row: &[f64], ask: TimingAsk) -> EntryPlan {
        let (p126, p252) = self.long_p(long_row);
        let bucket = bucket_of(r);
        let label = format!("{}, intensity decile {}", STATES[bucket / 10], bucket % 10 + 1);
        let mut best: Option<(f64, usize, usize)> = None; // (effective, window idx, certainty idx)
        for (w, &n) in self.windows.iter().enumerate() {
            if n > ask.within {
                continue;
            }
            let t = self.table(w, bucket);
            for (ci, &c) in CERTAINTIES.iter().enumerate() {
                if c + 1e-9 < ask.certainty {
                    continue;
                }
                let e = t.effective[ci];
                if e.is_finite() && best.is_none_or(|(b, _, _)| e < b) {
                    best = Some((e, w, ci));
                }
            }
        }
        // The plan exactly as asked: the longest window within reach, the
        // grid certainty nearest the request.
        let w_ask = self.windows.iter().rposition(|&n| n <= ask.within).unwrap_or(0);
        let ci_ask = nearest_certainty(ask.certainty);
        let asked = (self.table(w_ask, bucket).effective[ci_ask], w_ask, ci_ask);
        let beats_now = best.is_some_and(|(e, _, _)| -e >= ask.min_saving);
        // Show the best plan if it beats buying now; otherwise show the
        // asked-for plan, so its fill odds and expected cost are visible.
        let (eff, w, ci) = if beats_now { best.unwrap() } else { asked };
        let n = self.windows[w];
        let t = self.table(w, bucket);
        let scale = r.vol20 * (n as f64).sqrt();
        let c = CERTAINTIES[ci];
        let z_limit = limit_z(t, c);
        // The order sits FILL_THROUGH above the reached low, so a low at the
        // quantile trades through it.
        let limit = r.close * (z_limit * scale).exp() * (1.0 + FILL_THROUGH);
        let mut plan = EntryPlan {
            close: r.close,
            p_up_126: p126,
            p_up_252: p252,
            action: "limit",
            window: n,
            certainty: c,
            limit_price: limit,
            limit_discount: 1.0 - limit / r.close,
            p_fill: t.cdf(z_limit),
            typical_low: r.close * (t.median * scale).exp(),
            typical_low_day: ((t.low_day * n as f64).round() as usize).clamp(1, n),
            expected_saving: eff.exp() - 1.0,
            bucket: label,
            reason: String::new(),
        };
        if p252.is_finite() && p252 < ask.min_p_up {
            plan.action = "skip";
            plan.reason = format!("one-year P(up) {:.0}% is below your {:.0}% floor", 100.0 * p252, 100.0 * ask.min_p_up);
        } else if !beats_now || plan.limit_discount <= 0.0 {
            plan.action = "buy now";
            plan.reason = format!(
                "no limit good for ≤{} days with ≥{:.0}% fill odds beat buying now by {:.2}% on average; \
                 if you still wait, a limit at {:.2} ({:.2}% below) fills {:.0}% of the time but averages {:+.2}% vs buying now, misses included",
                ask.within,
                100.0 * ask.certainty,
                100.0 * ask.min_saving,
                plan.limit_price,
                100.0 * plan.limit_discount,
                100.0 * plan.p_fill,
                100.0 * plan.expected_saving
            );
        } else {
            plan.reason = format!(
                "limit {:.2}% below the close, good for {n} days: history filled it {:.0}% of the time and averaged {:.2}% cheaper than buying now, misses included",
                100.0 * plan.limit_discount,
                100.0 * plan.p_fill,
                -100.0 * plan.expected_saving
            );
        }
        plan
    }
}

/// The limit (in z units) that a share `c` of history traded through.
///
/// `P(z_min ≤ z) = c` ⇔ `z` is the `c`-quantile of `z_min`.  High certainty
/// means a shallow limit (a high quantile, near or above 0); low certainty
/// a deep one.
///
/// Never above 0: a "limit" above today's close is just buying now.
pub fn limit_z(t: &LowTable, c: f64) -> f64 {
    t.quantile(c).min(0.0)
}

/// The sell limit (in z units of the *highest high*) that a share `c` of
/// history traded through: `P(z_max ≥ z) = c` ⇔ the `(1 − c)`-quantile.
/// Never below 0: a sell limit under today's close is just selling now.
pub fn sell_z(t: &LowTable, c: f64) -> f64 {
    t.quantile(1.0 - c).max(0.0)
}

/// A recommended way to sell (or trim) one holding.
#[derive(Debug, Clone, Serialize)]
pub struct ExitPlan {
    /// `"sell now"`, `"sell limit"` (both only when the verdict is sell), or
    /// `"hold"` (the limit below is then a take-profit level, for reference).
    pub action: &'static str,
    pub window: usize,
    pub certainty: f64,
    /// Sell limit and its distance above the close (0.03 = 3% higher).
    pub limit_price: f64,
    pub limit_premium: f64,
    /// Historical probability that price trades through the limit in time.
    pub p_fill: f64,
    /// Typical highest price in the window, and the day it tends to come.
    pub typical_high: f64,
    pub typical_high_day: usize,
    /// Average exit vs selling now (+0.01 = 1% better), misses included
    /// (a miss sells at the window's last close).
    pub expected_gain: f64,
    pub reason: String,
}

/// Everything SD timing says about one stock today.
#[derive(Debug, Clone, Serialize)]
pub struct TimingPlan {
    pub date: chrono::NaiveDate,
    pub close: f64,
    pub p_up_126: f64,
    pub p_up_252: f64,
    /// The SD v2 number and its parts, for context.
    pub sd: f64,
    pub intensity: f64,
    pub state: &'static str,
    /// `"hold"` or `"sell"` for a position you own (see [`TimingConfig`]).
    pub verdict: &'static str,
    pub entry: EntryPlan,
    pub exit: ExitPlan,
}

/// Knobs for [`plan_for`].
#[derive(Debug, Clone, Copy)]
pub struct TimingConfig {
    pub entry: TimingAsk,
    /// Lowest acceptable fill probability for a sell limit.
    pub exit_certainty: f64,
    /// Longest wait for a sell limit, trading days.
    pub exit_within: usize,
    /// Verdict "sell" when six-month P(up) is below this.  **Off (0) by
    /// default**: walk-forward on 2019+, names with the *lowest* six-month
    /// P(up) went on to do *best* (see `reports/timing_research.txt`), so a
    /// sell verdict from it would have hurt.  Raise it only to experiment.
    pub sell_below_p126: f64,
    /// A sell limit must beat selling now by this much (log) on average.
    pub min_gain: f64,
}

impl Default for TimingConfig {
    fn default() -> Self {
        Self { entry: TimingAsk::default(), exit_certainty: 0.7, exit_within: 21, sell_below_p126: 0.0, min_gain: 0.0025 }
    }
}

impl TimingModel {
    /// Choose how to sell, given today's reading and whether the verdict is sell.
    pub fn exit_plan(&self, r: &Sd2Reading, cfg: &TimingConfig, sell: bool) -> ExitPlan {
        let bucket = bucket_of(r);
        let mut best: Option<(f64, usize, usize)> = None; // (effective, window, certainty), higher is better
        for (w, &n) in self.windows.iter().enumerate() {
            if n > cfg.exit_within || self.exit_tables.is_empty() {
                continue;
            }
            let t = self.exit_table(w, bucket);
            for (ci, &c) in CERTAINTIES.iter().enumerate() {
                if c + 1e-9 < cfg.exit_certainty {
                    continue;
                }
                let e = t.effective[ci];
                if e.is_finite() && best.is_none_or(|(b, _, _)| e > b) {
                    best = Some((e, w, ci));
                }
            }
        }
        let w_ask = self.windows.iter().rposition(|&n| n <= cfg.exit_within).unwrap_or(0);
        let ci_ask = nearest_certainty(cfg.exit_certainty);
        let beats_now = best.is_some_and(|(e, _, _)| e >= cfg.min_gain);
        let (eff, w, ci) = if beats_now { best.unwrap() } else { (self.exit_table(w_ask, bucket).effective[ci_ask], w_ask, ci_ask) };
        let n = self.windows[w];
        let t = self.exit_table(w, bucket);
        let scale = r.vol20 * (n as f64).sqrt();
        let zq = sell_z(t, CERTAINTIES[ci]);
        // The order sits FILL_THROUGH below the reached high.
        let limit = r.close * (zq * scale).exp() / (1.0 + FILL_THROUGH);
        let mut plan = ExitPlan {
            action: "hold",
            window: n,
            certainty: CERTAINTIES[ci],
            limit_price: limit,
            limit_premium: limit / r.close - 1.0,
            p_fill: 1.0 - t.cdf(zq),
            typical_high: r.close * (t.median * scale).exp(),
            typical_high_day: ((t.low_day * n as f64).round() as usize).clamp(1, n),
            expected_gain: eff.exp() - 1.0,
            reason: String::new(),
        };
        if !sell {
            plan.reason = format!(
                "for reference, a take-profit at {:.2} ({:.2}% above) within {n} days filled {:.0}% of the time",
                plan.limit_price,
                100.0 * plan.limit_premium,
                100.0 * plan.p_fill
            );
        } else if beats_now && plan.limit_premium > 0.0 {
            plan.action = "sell limit";
            plan.reason = format!(
                "sell with a limit {:.2}% above the close, good for {n} days: history filled it {:.0}% of the time and averaged {:+.2}% vs selling now, misses included",
                100.0 * plan.limit_premium,
                100.0 * plan.p_fill,
                100.0 * plan.expected_gain
            );
        } else {
            plan.action = "sell now";
            plan.reason = format!(
                "no sell limit within {} days with ≥{:.0}% fill odds beat selling now; waiting for {:.2} averages {:+.2}%",
                cfg.exit_within,
                100.0 * cfg.exit_certainty,
                plan.limit_price,
                100.0 * plan.expected_gain
            );
        }
        plan
    }
}

/// Index of the [`CERTAINTIES`] grid value nearest `c`.
pub fn nearest_certainty(c: f64) -> usize {
    CERTAINTIES
        .iter()
        .enumerate()
        .min_by(|a, b| (a.1 - c).abs().partial_cmp(&(b.1 - c).abs()).unwrap())
        .map(|x| x.0)
        .unwrap()
}

/// The embedded models, parsed once.
fn models() -> &'static (TimingModel, crate::sd2::engine::Sd2Model) {
    static M: std::sync::OnceLock<(TimingModel, crate::sd2::engine::Sd2Model)> = std::sync::OnceLock::new();
    M.get_or_init(|| (TimingModel::embedded(), crate::sd2::engine::Sd2Model::embedded()))
}

/// One call for everything: long-term P(up), entry plan, exit plan and
/// verdict for the last bar of `bars`.  `spy` and `vix` are the market's
/// weather (SPY and ^VIX daily bars; `vix` may be empty).  Needs about
/// 300 bars; ten years gives the monthly SD columns their full say.
pub fn plan_for(bars: &[DatedBar], spy: &[DatedBar], vix: &[DatedBar], cfg: &TimingConfig) -> Option<TimingPlan> {
    let (tm, sd_model) = models();
    let ohlcv: Vec<OHLCV> = bars.iter().map(|b| b.bar.clone()).collect();
    let dates: Vec<chrono::NaiveDate> = bars.iter().map(|b| b.date).collect();
    let r = crate::sd2::engine::sd2_latest(&ohlcv, sd_model)?;
    let mkt = MarketWeather::new(spy, vix);
    let long = long_rows(&ohlcv, &dates, &mkt);
    let row = long.last()?;
    let entry = tm.plan(&r, row, cfg.entry);
    let sell = entry.p_up_126.is_finite() && entry.p_up_126 < cfg.sell_below_p126;
    let exit = tm.exit_plan(&r, cfg, sell);
    Some(TimingPlan {
        date: *dates.last()?,
        close: r.close,
        p_up_126: entry.p_up_126,
        p_up_252: entry.p_up_252,
        sd: r.sd,
        intensity: r.intensity,
        state: STATES[state_of(&r)],
        verdict: if sell { "sell" } else { "hold" },
        entry,
        exit,
    })
}

/// Direction rows (long-term features) and SD readings for one symbol, the
/// way `sd_timing` computes them live and in research.
pub fn long_rows(bars: &[OHLCV], dates: &[chrono::NaiveDate], mkt: &MarketWeather) -> Vec<Vec<f64>> {
    let f = FeatureFrame::compute(bars, FeatureConfig::default());
    direction_frame(bars, dates, &f, mkt)
}

/// Convenience: build market weather from SPY and VIX bars.
pub fn weather(spy: &[DatedBar], vix: &[DatedBar]) -> MarketWeather {
    MarketWeather::new(spy, vix)
}

#[cfg(test)]
mod tests {
    use super::*;

    fn table() -> LowTable {
        // z_min uniformly spread over [-2, 0].
        let quantiles: Vec<f64> = (0..=100).map(|k| -2.0 + 2.0 * k as f64 / 100.0).collect();
        LowTable { quantiles, median: -1.0, low_day: 0.5, effective: vec![0.0; CERTAINTIES.len()], n: 1000 }
    }

    #[test]
    fn quantile_and_cdf_are_inverses() {
        let t = table();
        for c in [0.1, 0.3, 0.5, 0.7, 0.9] {
            assert!((t.cdf(t.quantile(c)) - c).abs() < 1e-9);
        }
    }

    #[test]
    fn higher_certainty_means_a_shallower_buy_limit() {
        let t = table();
        assert!(limit_z(&t, 0.9) > limit_z(&t, 0.5));
        assert!(limit_z(&t, 1.0) <= 0.0, "a buy limit never sits above the close");
    }

    #[test]
    fn higher_certainty_means_a_lower_sell_limit() {
        // Mirror: z_max uniformly over [0, 2].
        let mut t = table();
        t.quantiles = (0..=100).map(|k| 2.0 * k as f64 / 100.0).collect();
        assert!(sell_z(&t, 0.9) < sell_z(&t, 0.5));
        assert!(sell_z(&t, 0.5) >= 0.0);
        assert!((1.0 - t.cdf(sell_z(&t, 0.7)) - 0.7).abs() < 1e-9);
    }

    #[test]
    fn embedded_model_loads_and_has_every_table() {
        let m = TimingModel::embedded();
        assert_eq!(m.tables.len(), WINDOWS.len());
        assert_eq!(m.exit_tables.len(), WINDOWS.len());
        assert!(m.tables.iter().all(|w| w.len() == 30));
        assert_eq!(m.long.len(), LONG_HORIZONS.len());
    }
}