或许是优化平仓，添加观测条件3

strategy/src/predictor.rs

@@ -46,8 +46,8 @@ pub struct Predictor {
     pub bid_delta: Decimal,                                                     // δb
 
     pub mid_price_time_vec: FixedTimeRangeDeque<Decimal>,                       // 中间价格队列，100ms以内的所有中间价格
-    pub fair_price_time_vec: FixedTimeRangeDeque<Decimal>,                      // 公平价格队列，50ms以内的所有公平价格
-    pub spread_sma_1000_time_vec: FixedTimeRangeDeque<Decimal>,                 // spread队列，100ms以内的所有spread_sma_1000
+    pub fair_price_time_vec: FixedTimeRangeDeque<Decimal>,                      // 公平价格队列，10ms以内的所有公平价格
+    pub spread_sma_1000_time_vec: FixedTimeRangeDeque<Decimal>,                 // spread队列，10ms以内的所有spread_sma_1000
     pub fair_price_vec: Vec<Decimal>,                                           // 公平价格列表，0表示做市所，1表示参考所
     pub fair_price: Decimal,                                                    // 预定价格
     pub fair_rate_focus: Decimal,                                               // 变化幅度焦点
@@ -155,9 +155,9 @@ impl Predictor {
             ask_delta: Default::default(),
             bid_delta: Default::default(),
 
+            spread_sma_1000_time_vec: FixedTimeRangeDeque::new(10_000),
             fair_price_time_vec: FixedTimeRangeDeque::new(10_000),
             mid_price_time_vec: FixedTimeRangeDeque::new(100_000),
-            spread_sma_1000_time_vec: FixedTimeRangeDeque::new(500_000),
             fair_price: Default::default(),
             fair_rate_focus: Default::default(),
             fair_price_when_ordering: Default::default(),
@@ -303,6 +303,11 @@ impl Predictor {
             self.fair_price = fair_price_part0 + fair_price_part1;
             self.fair_price_time_vec.push_back(self.fair_price);
 
+            let last_fair_price = self.fair_price_time_vec.deque.iter().last().unwrap();
+            let first_fair_price = self.fair_price_time_vec.deque[0];
+            let mut rate = (last_fair_price - first_fair_price) / first_fair_price;
+            rate.rescale(8);
+
             // 重置焦点，条件1
             if !self.fair_rate_focus.is_zero() {
                 // 向上涨，并且mid下穿fair，视为观测阶段结束
@@ -319,14 +324,13 @@ impl Predictor {
             if !self.fair_rate_focus.is_zero() && !self.inventory.is_zero() {
                 self.fair_rate_focus = Decimal::ZERO;
             }
+            // 重置焦点，条件3
+            if !self.fair_rate_focus.is_zero() && rate.abs() > self.params.open {
+                self.fair_rate_focus = Decimal::ZERO;
+            }
 
             // 更新程序关注的变化幅度焦点
             if self.fair_rate_focus.is_zero() {
-                let last_fair_price = self.fair_price_time_vec.deque.iter().last().unwrap();
-                let first_fair_price = self.fair_price_time_vec.deque[0];
-                let mut rate = (last_fair_price - first_fair_price) / first_fair_price;
-                rate.rescale(8);
-
                 // 只有有强度的rate才有资格被称为针
                 if rate.abs() > self.params.open {
                     // 向上涨，并且fair下穿mid，视为观测阶段开始
@@ -415,7 +419,7 @@ impl Predictor {
                 //
                 // self.ask_delta = self.mid_price * close_rate * self.t_diff;
                 self.ask_delta = self.mid_price * self.params.close;
-            } else if self.mid_price > self.fair_price {
+            } else if self.spread_sma < Decimal::ZERO {
                 self.ask_delta = self.mid_price * self.params.close;
             }
 
@@ -428,7 +432,7 @@ impl Predictor {
                 //
                 // self.bid_delta = self.mid_price * close_rate * self.t_diff;
                 self.bid_delta = self.mid_price * self.params.close;
-            } else if self.mid_price < self.fair_price {
+            } else if self.spread_sma > Decimal::ZERO {
                 self.bid_delta = self.mid_price * self.params.close;
             }
 
@@ -551,12 +555,10 @@ impl Predictor {
 
         let inventory = self.inventory;
 
-        let last_fair_price = self.fair_price_time_vec.deque.iter().last().unwrap();
-        let first_fair_price = self.fair_price_time_vec.deque[0];
-        let mut rate = (last_fair_price - first_fair_price) / first_fair_price;
-        rate.rescale(8);
+        let last_spread_sma = self.spread_sma_1000_time_vec.deque.iter().last().unwrap();
+        let first_spread_sma = self.spread_sma_1000_time_vec.deque[0];
 
-        let sigma_square = rate;
+        let sigma_square = last_spread_sma - first_spread_sma;
         let gamma = now - self.last_update_time;
 
         let kappa = self.fair_rate_focus;