修复预计算rolling缺失语义

crates/fidc-core/src/platform_expr_strategy.rs

@@ -545,20 +545,28 @@ fn precomputed_stock_rolling_mean(
     field: &str,
     lookback: usize,
 ) -> Option<f64> {
-    let keys: &[&str] = match (field.trim().to_ascii_lowercase().as_str(), lookback) {
+    if lookback == 0 {
-        ("close" | "prev_close" | "stock_close" | "price", 5) => &["ma5_prev_close", "ma5"],
+        return None;
-        ("close" | "prev_close" | "stock_close" | "price", 10) => &["ma10_prev_close", "ma10"],
+    }
-        ("close" | "prev_close" | "stock_close" | "price", 20) => &["ma20_prev_close", "ma20"],
+    let value_for = |key: &str| {
-        ("close" | "prev_close" | "stock_close" | "price", 30) => &["ma30_prev_close", "ma30"],
+        extra_factors
-        ("volume" | "stock_volume", 5) => &["avg_volume5", "vma5"],
+            .get(key)
-        ("volume" | "stock_volume", 20) => &["avg_volume20", "vma20"],
+            .copied()
-        ("volume" | "stock_volume", 60) => &["avg_volume60", "vma60"],
-        ("volume" | "stock_volume", 100) => &["avg_volume100", "vma100"],
-        _ => return None,
-    };
-    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<f64> {
         let precomputed = precomputed_stock_rolling_mean(extra_factors, field, lookback);
         if self.config.prefer_precomputed_rolling_factors {
-            precomputed.or_else(|| {
+            precomputed
-                ctx.data
-                    .market_decision_numeric_moving_average(date, symbol, field, lookback)
-            })
         } 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<DailyMarketSnapshot> = (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<BenchmarkSnapshot> = 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]