修正微盘买入预算与表达式性能

crates/fidc-core/src/data.rs

@@ -453,11 +453,13 @@ struct SymbolPriceSeries {
     closes: Vec<f64>,
     prev_closes: Vec<f64>,
     last_prices: Vec<f64>,
-    paused: Vec<bool>,
     open_prefix: Vec<f64>,
     close_prefix: Vec<f64>,
     prev_close_prefix: Vec<f64>,
     last_prefix: Vec<f64>,
+    unpaused_volumes: Vec<f64>,
+    unpaused_volume_prefix: Vec<f64>,
+    unpaused_count_prefix: Vec<usize>,
 }
 
 impl SymbolPriceSeries {
@@ -470,11 +472,20 @@ impl SymbolPriceSeries {
         let closes = sorted.iter().map(|row| row.close).collect::<Vec<_>>();
         let prev_closes = sorted.iter().map(|row| row.prev_close).collect::<Vec<_>>();
         let last_prices = sorted.iter().map(|row| row.last_price).collect::<Vec<_>>();
-        let paused = sorted.iter().map(|row| row.paused).collect::<Vec<_>>();
         let open_prefix = prefix_sums(&opens);
         let close_prefix = prefix_sums(&closes);
         let prev_close_prefix = prefix_sums(&prev_closes);
         let last_prefix = prefix_sums(&last_prices);
+        let mut unpaused_volumes = Vec::new();
+        let mut unpaused_count_prefix = Vec::with_capacity(sorted.len() + 1);
+        unpaused_count_prefix.push(0);
+        for row in &sorted {
+            if !row.paused {
+                unpaused_volumes.push(row.volume as f64);
+            }
+            unpaused_count_prefix.push(unpaused_volumes.len());
+        }
+        let unpaused_volume_prefix = prefix_sums(&unpaused_volumes);
 
         Self {
             snapshots: sorted,
@@ -483,11 +494,13 @@ impl SymbolPriceSeries {
             closes,
             prev_closes,
             last_prices,
-            paused,
             open_prefix,
             close_prefix,
             prev_close_prefix,
             last_prefix,
+            unpaused_volumes,
+            unpaused_volume_prefix,
+            unpaused_count_prefix,
         }
     }
 
@@ -597,11 +610,12 @@ impl SymbolPriceSeries {
             return None;
         }
         let end = self.end_index(date)?;
-        let values = self.trailing_unpaused_volumes(end, lookback)?;
+        let end_count = *self.unpaused_count_prefix.get(end)?;
-        if values.len() < lookback {
+        if end_count < lookback {
             return None;
         }
-        let sum = values.iter().sum::<f64>();
+        let start_count = end_count - lookback;
+        let sum = self.unpaused_volume_prefix[end_count] - self.unpaused_volume_prefix[start_count];
         Some(sum / lookback as f64)
     }
 
@@ -621,22 +635,12 @@ impl SymbolPriceSeries {
         if lookback == 0 || end == 0 {
             return None;
         }
-        let mut values = Vec::with_capacity(lookback);
+        let end_count = *self.unpaused_count_prefix.get(end)?;
-        for idx in (0..end).rev() {
+        if end_count < lookback {
-            if self.paused.get(idx).copied().unwrap_or(false) {
+            return None;
-                continue;
-            }
-            values.push(self.snapshots[idx].volume as f64);
-            if values.len() == lookback {
-                break;
-            }
-        }
-        if values.len() < lookback {
-            None
-        } else {
-            values.reverse();
-            Some(values)
         }
+        let start_count = end_count - lookback;
+        Some(self.unpaused_volumes[start_count..end_count].to_vec())
     }
 
     fn end_index(&self, date: NaiveDate) -> Option<usize> {
@@ -2146,12 +2150,10 @@ impl DataSet {
                 self.market_moving_average(date, symbol, lookback, PriceField::Close)
             }
             "volume" | "stock_volume" => self
-                .factor_moving_average(date, symbol, "daily_volume", lookback)
+                .market_series_by_symbol
-                .or_else(|| {
+                .get(symbol)
-                    self.market_series_by_symbol
+                .and_then(|series| series.current_volume_moving_average(date, lookback))
-                        .get(symbol)
+                .or_else(|| self.factor_moving_average(date, symbol, "daily_volume", lookback)),
-                        .and_then(|series| series.current_volume_moving_average(date, lookback))
-                }),
             "day_open" | "dayopen" => {
                 self.market_moving_average(date, symbol, lookback, PriceField::DayOpen)
             }