上号，测试。

strategy/src/predictor.rs

@@ -31,7 +31,7 @@ pub struct Predictor {
     pub trades_volume_short: Decimal,                                           // 过去10秒的成交量总和
     pub trades_volume_short_ema: Decimal,                                       // 过去10秒的成交量总和的ema
     pub spread: Decimal,                                                        // 当前价差
-    pub spread_ema_1000: Decimal,                                               // 价差的ema，1000级别
+    pub spread_ema: Decimal,                                                    // 价差的ema，1000级别
     pub spread_diff: Decimal,                                                   // 价差与价差ema的diff，可以衡量价差扩大行为
 
     pub optimal_ask_price: Decimal,                                             // 卖出挂单价
@@ -158,7 +158,7 @@ impl Predictor {
             trades_volume_short: Default::default(),
             trades_volume_short_ema: Default::default(),
             spread: Default::default(),
-            spread_ema_1000: Default::default(),
+            spread_ema: Default::default(),
             spread_diff: Default::default(),
             optimal_ask_price: Default::default(),
             optimal_bid_price: Default::default(),
@@ -168,7 +168,7 @@ impl Predictor {
             bid_delta: Default::default(),
 
             fair_price_time_vec: FixedTimeRangeDeque::new((params.second_observation_time.to_f64().unwrap() * 1_000_000f64).to_i64().unwrap()),
-            fair_price_long_time_vec: FixedTimeRangeDeque::new(Self::TRADE_LONG_RANGE_MICROS),
+            fair_price_long_time_vec: FixedTimeRangeDeque::new((params.second_observation_time.to_f64().unwrap() * 1_000_000f64).to_i64().unwrap() * 2),
             mid_price_time_vec: FixedTimeRangeDeque::new((params.second_observation_time.to_f64().unwrap() * 1_000_000f64).to_i64().unwrap()),
             fair_price: Default::default(),
             fair_price_ema_short: Default::default(),
@@ -322,7 +322,7 @@ impl Predictor {
         self.processor().await;
     }
 
-    pub fn get_real_rate(price_vec: &FixedTimeRangeDeque<Decimal>) -> Decimal {
+    pub fn get_real_rate(price_vec: &FixedTimeRangeDeque<Decimal>) -> (Decimal, Decimal) {
         let last_fair_price = price_vec.deque.iter().last().unwrap();
         let min_price = price_vec.deque.iter().min().unwrap();
         let max_price = price_vec.deque.iter().max().unwrap();
@@ -330,9 +330,9 @@ impl Predictor {
         let down_rate = (max_price - last_fair_price) / max_price;
 
         if up_rate > down_rate {
-            up_rate
+            (up_rate, min_price.clone())
         } else {
-            -down_rate
+            (-down_rate, max_price.clone())
         }
     }
 
@@ -386,20 +386,20 @@ impl Predictor {
                 return;
             }
 
-            let mut fair_rate = Self::get_real_rate(&self.fair_price_time_vec);
+            let (mut fair_rate, fair_start) = Self::get_real_rate(&self.fair_price_time_vec);
             fair_rate.rescale(8);
-            let mut fair_long_rate = Self::get_real_rate(&self.fair_price_long_time_vec);
+            let (mut fair_long_rate, _) = Self::get_real_rate(&self.fair_price_long_time_vec);
             fair_long_rate.rescale(8);
-            let mut mid_rate = Self::get_real_rate(&self.mid_price_time_vec);
+            let (mut mid_rate, mid_start) = Self::get_real_rate(&self.mid_price_time_vec);
             mid_rate.rescale(8);
 
             // 重置开仓焦点，条件1
             if !self.fair_rate_focus_open.is_zero() {
-                if self.fair_rate_focus_open < Decimal::ZERO && self.spread_ema_1000 < Decimal::ZERO {
+                if self.fair_rate_focus_open < Decimal::ZERO && self.spread_ema < Decimal::ZERO {
                     self.fair_rate_focus_open = Decimal::ZERO;
                 }
 
-                if self.fair_rate_focus_open > Decimal::ZERO && self.spread_ema_1000 > Decimal::ZERO {
+                if self.fair_rate_focus_open > Decimal::ZERO && self.spread_ema > Decimal::ZERO {
                     self.fair_rate_focus_open = Decimal::ZERO;
                 }
             }
@@ -421,8 +421,15 @@ impl Predictor {
             }
             // 更新程序关注的开仓焦点
             if self.fair_rate_focus_open.is_zero() && self.inventory.is_zero() {
-                // 只有有强度的rate才有资格被称为针，并且差价够大，
-                if fair_rate.abs() > self.params.open_activate && mid_rate.abs() > self.params.open_activate && self.spread_diff.abs() > self.params.min_spread {
+                // 是同起点
+                let mut is_cross = fair_rate.abs() > self.params.open_activate;
+                is_cross = is_cross && mid_rate.abs() > self.params.open_activate;
+                is_cross = is_cross && ((mid_start - fair_start) / mid_start).abs() < dec!(0.0005);
+
+                // 最近80%的波动都发生在最近1半的时间里
+                let is_high_speed = fair_rate.abs() > fair_long_rate.abs() * dec!(0.8) && fair_rate * fair_long_rate > Decimal::ZERO;
+
+                if is_cross && is_high_speed && self.spread_diff.abs() > self.params.min_spread {
                     // 向上涨，并且fair下穿mid，视为观测阶段开始
                     if mid_rate > Decimal::ZERO && fair_rate > Decimal::ZERO && self.spread_diff < Decimal::ZERO {
                         self.fair_rate_focus_open = self.spread_diff;
@@ -542,15 +549,15 @@ impl Predictor {
         // self.spread.rescale(8);
         self.spread_vec.push(self.spread);
 
-        self.spread_ema_1000 = if self.spread_ema_1000.is_zero() {
+        self.spread_ema = if self.spread_ema.is_zero() {
             self.spread
         } else {
-            self.spread_ema_1000 * dec!(0.999) + self.spread * dec!(0.001)
+            self.spread_ema * dec!(0.995) + self.spread * dec!(0.005)
         };
         // self.spread_sma_1000.rescale(8);
         // self.spread_sma_1000_time_vec.push_back(self.spread_ema_1000);
 
-        self.spread_diff = self.spread - self.spread_ema_1000;
+        self.spread_diff = self.spread - self.spread_ema;
 
         while self.spread_vec.len() > 1_000 {
             self.spread_vec.remove(0);
@@ -712,7 +719,7 @@ impl Predictor {
         let fair_price = self.fair_price;
 
         let spread = self.spread;
-        let spread_max = self.spread_ema_1000;
+        let spread_max = self.spread_ema;
         let spread_min = self.spread_diff;
         // let spread = self.price_times_avg;
         // let spread_max = self.fair_price_vec[1] / self.fair_price_vec[0];
@@ -723,10 +730,10 @@ impl Predictor {
 
         let inventory = self.inventory;
 
-        let sigma_square = if self.fair_price_long_time_vec.len() > 1 {
+        let (sigma_square, _) = if self.fair_price_long_time_vec.len() > 1 {
             Self::get_real_rate(&self.fair_price_long_time_vec)
         } else {
-            Decimal::ZERO
+            (Decimal::ZERO, Decimal::ZERO)
         };
         // let sigma_square = self.error_rate;