真*接针

strategy/src/predictor.rs

@@ -45,8 +45,11 @@ pub struct Predictor {
     pub ask_delta: Decimal,                                                     // δa
     pub bid_delta: Decimal,                                                     // δb
 
-    pub fair_price_vec: Vec<Decimal>,                                           // 预定价格队列
+    pub mid_price_time_vec: FixedTimeRangeDeque<Decimal>,                       // 中间价格队列，100ms以内的所有中间价格
+    pub fair_price_time_vec: FixedTimeRangeDeque<Decimal>,                      // 公平价格队列，100ms以内的所有公平价格
+    pub fair_price_vec: Vec<Decimal>,                                           // 公平价格列表，0表示做市所，1表示参考所
     pub fair_price: Decimal,                                                    // 预定价格
+    pub fair_rate_focus: Decimal,                                               // 变化幅度焦点
     pub fair_price_when_ordering: Decimal,                                      // 下单时的预定价格
     pub price_times_avg: Decimal,                                               // 公平所与做市所的价格倍率的平均值
     pub is_regressed: bool,                                                     // 做市所的价格是否已经回归
@@ -151,7 +154,10 @@ impl Predictor {
             ask_delta: Default::default(),
             bid_delta: Default::default(),
 
+            fair_price_time_vec: FixedTimeRangeDeque::new(100_000),
+            mid_price_time_vec: FixedTimeRangeDeque::new(100_000),
             fair_price: Default::default(),
+            fair_rate_focus: Default::default(),
             fair_price_when_ordering: Default::default(),
 
             price_times_avg: Default::default(),
@@ -190,6 +196,8 @@ impl Predictor {
             self.ask_price = depth.asks[0].price;
             self.bid_price = depth.bids[0].price;
             self.mid_price = (self.ask_price + self.bid_price) / Decimal::TWO;
+
+            self.mid_price_time_vec.push_back(self.mid_price);
         }
 
         self.update_fair_price(depth, index).await;
@@ -267,8 +275,9 @@ impl Predictor {
         let b1 = &depth.bids[0];
 
         // https://quant.stackexchange.com/questions/50651/how-to-understand-micro-price-aka-weighted-mid-price
-        let total = a1.value + b1.value;
-        let fair_price = a1.price * b1.value / total + b1.price * a1.value / total;
+        // let total = a1.value + b1.value;
+        // let fair_price = a1.price * b1.value / total + b1.price * a1.value / total;
+        let fair_price = (a1.price + b1.price) / Decimal::TWO;
 
         self.fair_price_vec[index] = if self.fair_price_vec[index].is_zero() {
             fair_price
@@ -290,6 +299,43 @@ impl Predictor {
             let fair_price_part0 = self.fair_price_vec[0] * dec!(0.2);
             let fair_price_part1 = (self.fair_price_vec[1] / self.price_times_avg) * dec!(0.8);
             self.fair_price = fair_price_part0 + fair_price_part1;
+            self.fair_price_time_vec.push_back(self.fair_price);
+
+            // 重置焦点
+            if !self.fair_rate_focus.is_zero() && self.mid_price_time_vec.deque.len() >= 2 && self.fair_price_time_vec.deque.len() >= 2 {
+                let mid_price_prev = self.mid_price_time_vec.deque.get(self.mid_price_time_vec.deque.len() - 2).unwrap();
+                let fair_price_prev = self.fair_price_time_vec.deque.get(self.fair_price_time_vec.deque.len() - 2).unwrap();
+
+                // 向上涨，并且mid下穿fair，视为观测阶段结束
+                if self.fair_rate_focus > Decimal::ZERO && mid_price_prev > fair_price_prev && self.mid_price < self.fair_price {
+                    self.fair_rate_focus = Decimal::ZERO;
+                }
+
+                // 向下跌，并且mid上穿fair，视为观测阶段结束
+                if self.fair_rate_focus < Decimal::ZERO && mid_price_prev < fair_price_prev && self.mid_price > self.fair_price {
+                    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 {
+                    if self.fair_rate_focus > Decimal::ZERO && self.mid_price > self.fair_price {
+                        self.fair_rate_focus = rate;
+                    }
+
+                    // 向下跌，并且mid上穿fair，视为观测阶段结束
+                    if self.fair_rate_focus < Decimal::ZERO && self.mid_price < self.fair_price {
+                        self.fair_rate_focus = rate;
+                    }
+                }
+            }
         }
 
         // 判断价格是否回归
@@ -344,10 +390,12 @@ impl Predictor {
             return;
         }
 
-        // let is_open_long = self.spread_sma_1000 - self.spread_sma > self.params.open;
-        // let is_open_short = self.spread_sma_1000 - self.spread_sma < self.params.open * Decimal::NEGATIVE_ONE;
-        let is_open_short = self.spread_sma_1000 - self.spread_sma > self.params.open;
-        let is_open_long = self.spread_sma_1000 - self.spread_sma < self.params.open * Decimal::NEGATIVE_ONE;
+        // 可能是趋势
+        // let is_open_long = self.spread_sma_1000 - self.spread_sma > self.params.open && self.fair_price > self.mid_price;
+        // let is_open_short = self.spread_sma_1000 - self.spread_sma < self.params.open * Decimal::NEGATIVE_ONE && self.fair_price < self.mid_price;
+        // 可能是接针
+        let is_open_long = self.spread_sma_1000 - self.spread_sma < self.params.open * Decimal::NEGATIVE_ONE && self.fair_price > self.mid_price;
+        let is_open_short = self.spread_sma_1000 - self.spread_sma > self.params.open && self.fair_price < self.mid_price;
         let is_close_long = self.inventory > Decimal::ZERO;
         let is_close_short = self.inventory < Decimal::ZERO;
 
@@ -478,9 +526,9 @@ impl Predictor {
         let bid_price = self.bid_price;
         let last_price = self.last_price;
 
-        let spread = self.spread_sma_1000 - self.spread_sma;
-        let spread_max = Self::UN_VIEW;
-        let spread_min = Self::UN_VIEW;
+        let spread = self.spread_sma;
+        let spread_max = self.spread_sma_2000;
+        let spread_min = self.spread_sma_1000;
         // let spread = self.price_times_avg;
         // let spread_max = self.fair_price_vec[1] / self.fair_price_vec[0];
         // let spread_min = self.fair_price / self.mid_price;
@@ -491,7 +539,8 @@ impl Predictor {
         let inventory = self.inventory;
         let sigma_square = if self.is_regressed { Decimal::ONE } else { Decimal::ZERO };
         let gamma = now - self.last_update_time;
-        let kappa = self.fair_price / self.mid_price;
+
+        let kappa = self.fair_rate_focus;
 
         let flow_ratio = Decimal::ZERO;
         let ref_price = self.fair_price;

strategy/src/strategy.rs

@@ -1236,7 +1236,7 @@ impl Strategy {
 
         self._cancel_open(&mut command, local_orders, predictor);   // 撤单命令处理
         self._post_close(&mut command, local_orders, predictor);    // 平仓单命令处理
-        self._post_open(&mut command, local_orders, predictor);     // 限价单命令处理
+        // self._post_open(&mut command, local_orders, predictor);     // 限价单命令处理
         self._check_local_orders(&mut command, local_orders);       // 固定时间检查超时订单
         self._update_in_cancel(&mut command, local_orders);         // 更新撤单队列，是一个filter
         self._check_request_limit(&mut command);                    // 限制频率，移除不合规则之订单，是一个filter