From 5a1534e51e00684ea8beb0b81ec68bae4ba40a55 Mon Sep 17 00:00:00 2001 From: boris Date: Tue, 7 Jul 2026 23:05:26 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E9=A2=84=E8=AE=A1=E7=AE=97ro?= =?UTF-8?q?lling=E7=BC=BA=E5=A4=B1=E8=AF=AD=E4=B9=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../fidc-core/src/platform_expr_strategy.rs | 173 ++++++++++++++++-- 1 file changed, 156 insertions(+), 17 deletions(-) diff --git a/crates/fidc-core/src/platform_expr_strategy.rs b/crates/fidc-core/src/platform_expr_strategy.rs index ad98033..8eec00b 100644 --- a/crates/fidc-core/src/platform_expr_strategy.rs +++ b/crates/fidc-core/src/platform_expr_strategy.rs @@ -545,20 +545,28 @@ fn precomputed_stock_rolling_mean( field: &str, lookback: usize, ) -> Option { - let keys: &[&str] = match (field.trim().to_ascii_lowercase().as_str(), lookback) { - ("close" | "prev_close" | "stock_close" | "price", 5) => &["ma5_prev_close", "ma5"], - ("close" | "prev_close" | "stock_close" | "price", 10) => &["ma10_prev_close", "ma10"], - ("close" | "prev_close" | "stock_close" | "price", 20) => &["ma20_prev_close", "ma20"], - ("close" | "prev_close" | "stock_close" | "price", 30) => &["ma30_prev_close", "ma30"], - ("volume" | "stock_volume", 5) => &["avg_volume5", "vma5"], - ("volume" | "stock_volume", 20) => &["avg_volume20", "vma20"], - ("volume" | "stock_volume", 60) => &["avg_volume60", "vma60"], - ("volume" | "stock_volume", 100) => &["avg_volume100", "vma100"], - _ => return None, + if lookback == 0 { + return None; + } + let value_for = |key: &str| { + extra_factors + .get(key) + .copied() + .filter(|value| value.is_finite()) }; - keys.iter() - .find_map(|key| extra_factors.get(*key).copied()) - .filter(|value| value.is_finite()) + match field.trim().to_ascii_lowercase().as_str() { + "close" | "prev_close" | "stock_close" | "price" => { + let primary = format!("ma{lookback}_prev_close"); + let alias = format!("ma{lookback}"); + value_for(&primary).or_else(|| value_for(&alias)) + } + "volume" | "stock_volume" => { + let primary = format!("avg_volume{lookback}"); + let alias = format!("vma{lookback}"); + value_for(&primary).or_else(|| value_for(&alias)) + } + _ => None, + } } pub struct PlatformExprStrategy { @@ -2584,10 +2592,7 @@ impl PlatformExprStrategy { ) -> Option { let precomputed = precomputed_stock_rolling_mean(extra_factors, field, lookback); if self.config.prefer_precomputed_rolling_factors { - precomputed.or_else(|| { - ctx.data - .market_decision_numeric_moving_average(date, symbol, field, lookback) - }) + precomputed } else { let computed = ctx .data @@ -23922,6 +23927,130 @@ mod tests { assert_eq!(stock.stock_volume_ma5, 1_000.0); } + #[test] + fn platform_stock_state_keeps_missing_precomputed_rolling_as_missing() { + let current = d(2025, 5, 30); + let start = current - chrono::Duration::days(100); + let symbol = "300022.SZ"; + let market_rows: Vec = (0..=100) + .map(|idx| { + let date = start + chrono::Duration::days(idx); + DailyMarketSnapshot { + date, + symbol: symbol.to_string(), + timestamp: Some(format!("{date} 10:15:00")), + day_open: 10.0, + open: 10.0, + high: 10.2, + low: 9.8, + close: 10.0, + last_price: 10.0, + bid1: 9.99, + ask1: 10.01, + prev_close: 9.9, + volume: 1_000, + minute_volume: 1_000, + bid1_volume: 1_000, + ask1_volume: 1_000, + trading_phase: Some("continuous".to_string()), + paused: false, + upper_limit: 11.0, + lower_limit: 9.0, + price_tick: 0.01, + } + }) + .collect(); + let benchmark_rows: Vec = market_rows + .iter() + .map(|row| BenchmarkSnapshot { + date: row.date, + benchmark: "000852.SH".to_string(), + open: 1000.0, + close: 1002.0, + prev_close: 998.0, + volume: 1_000_000, + }) + .collect(); + let data = DataSet::from_components( + vec![Instrument { + symbol: symbol.to_string(), + name: symbol.to_string(), + board: "SZ".to_string(), + round_lot: 100, + listed_at: Some(d(2020, 1, 1)), + delisted_at: None, + status: "active".to_string(), + }], + market_rows, + vec![DailyFactorSnapshot { + date: current, + symbol: symbol.to_string(), + market_cap_bn: 20.0, + free_float_cap_bn: 20.0, + pe_ttm: 0.0, + turnover_ratio: None, + effective_turnover_ratio: None, + extra_factors: BTreeMap::from([("ma5_prev_close".to_string(), 10.0)]), + }], + vec![CandidateEligibility { + date: current, + symbol: symbol.to_string(), + is_st: false, + is_star_st: false, + is_new_listing: false, + is_paused: false, + allow_buy: true, + allow_sell: true, + is_kcb: false, + is_one_yuan: false, + risk_level_code: None, + }], + benchmark_rows, + ) + .expect("dataset"); + let portfolio = PortfolioState::new(100_000.0); + let subscriptions = BTreeSet::new(); + let ctx = StrategyContext { + execution_date: current, + decision_date: current, + decision_index: 100, + data: &data, + portfolio: &portfolio, + futures_account: None, + open_orders: &[], + dynamic_universe: None, + subscriptions: &subscriptions, + process_events: &[], + active_process_event: None, + active_datetime: None, + order_events: &[], + fills: &[], + }; + + let mut cfg = PlatformExprStrategyConfig::microcap_rotation(); + cfg.signal_symbol = symbol.to_string(); + cfg.prefer_precomputed_rolling_factors = true; + cfg.stock_filter_expr = "rolling_mean(\"volume\", 100) > 0".to_string(); + let strategy = PlatformExprStrategy::new(cfg.clone()); + let stock = strategy + .stock_state_with_factor_date(&ctx, current, current, symbol) + .expect("stock state"); + assert!(stock.stock_volume_ma100.is_nan()); + let day = strategy.day_state(&ctx, current).expect("day state"); + assert!( + !strategy + .stock_passes_expr(&ctx, &day, &stock) + .expect("stock expr") + ); + + cfg.prefer_precomputed_rolling_factors = false; + let strategy = PlatformExprStrategy::new(cfg); + let stock = strategy + .stock_state_with_factor_date(&ctx, current, current, symbol) + .expect("stock state"); + assert_eq!(stock.stock_volume_ma100, 1_000.0); + } + #[test] fn precomputed_rolling_mean_ignores_strategy_specific_v104_labels() { let mut extra_factors = BTreeMap::new(); @@ -23938,16 +24067,26 @@ mod tests { ); extra_factors.insert("ma5_prev_close".to_string(), 10.5); + extra_factors.insert("ma40_prev_close".to_string(), 11.5); extra_factors.insert("avg_volume100".to_string(), 120_000.0); + extra_factors.insert("avg_volume40".to_string(), 40_000.0); assert_eq!( precomputed_stock_rolling_mean(&extra_factors, "close", 5), Some(10.5) ); + assert_eq!( + precomputed_stock_rolling_mean(&extra_factors, "close", 40), + Some(11.5) + ); assert_eq!( precomputed_stock_rolling_mean(&extra_factors, "volume", 100), Some(120_000.0) ); + assert_eq!( + precomputed_stock_rolling_mean(&extra_factors, "volume", 40), + Some(40_000.0) + ); } #[test]