使用微价格

strategy/src/predictor.rs

@@ -265,24 +265,15 @@ impl Predictor {
 
         let a1 = &depth.asks[0];
         let b1 = &depth.bids[0];
-        let mid = (a1.price + b1.price) / Decimal::TWO;
 
-        let i_upper = (a1.value - b1.value) / (a1.value + b1.value);
-        // let s_upper = (a1.price - b1.price) / mid;
-        // let f_t = Decimal::ZERO;
-        // let s = (s_upper + f_t) / Decimal::TWO;
-        //
-        // let a_upper_t = dec!(0.6);
-        // let c_t = dec!(0);
-        // let theta = a_upper_t * s + c_t;
-        // let fair_price = mid + theta * (i_upper * (i_upper.powd(Decimal::TWO) + Decimal::ONE)) / Decimal::TWO;
-
-        let fair_price = mid + (a1.price - b1.price) * i_upper / Decimal::TWO;
+        // 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;
 
         self.fair_price_vec[index] = if self.fair_price_vec[index].is_zero() {
             fair_price
         } else {
-            self.fair_price_vec[index] * dec!(0.9) + fair_price * dec!(0.1)
+            self.fair_price_vec[index] * dec!(0.95) + fair_price * dec!(0.05)
         };
         self.fair_price_vec[index].rescale(self.mid_price.scale());
         self.volume_vec[index] = a1.size + b1.size;
@@ -302,9 +293,9 @@ impl Predictor {
         }
 
         // 判断价格是否回归
-        if !self.is_regressed && self.inventory > Decimal::ZERO && self.fair_price < self.mid_price * (Decimal::ONE - self.params.open) {
+        if !self.is_regressed && self.inventory > Decimal::ZERO && self.spread_sma_1000 < max(self.spread_sma, self.spread_sma_2000) {
             self.is_regressed = true
-        } else if !self.is_regressed && self.inventory < Decimal::ZERO && self.fair_price > self.mid_price * (Decimal::ONE + self.params.open) {
+        } else if !self.is_regressed && self.inventory < Decimal::ZERO && self.spread_sma_1000 > min(self.spread_sma, self.spread_sma_2000) {
             self.is_regressed = true
         }
     }
@@ -315,7 +306,7 @@ impl Predictor {
         }
 
         self.spread = (self.fair_price - self.mid_price) / self.mid_price;
-        self.spread.rescale(8);
+        // self.spread.rescale(8);
         self.spread_vec.push(self.spread);
 
         self.spread_sma = if self.spread_sma.is_zero() {
@@ -323,21 +314,21 @@ impl Predictor {
         } else {
             self.spread_sma * dec!(0.9998) + self.spread * dec!(0.0002)
         };
-        self.spread_sma.rescale(8);
+        // self.spread_sma.rescale(8);
 
         self.spread_sma_2000 = if self.spread_sma_2000.is_zero() {
             self.spread
         } else {
             self.spread_sma_2000 * dec!(0.9995) + self.spread * dec!(0.0005)
         };
-        self.spread_sma_2000.rescale(8);
+        // self.spread_sma_2000.rescale(8);
 
         self.spread_sma_1000 = if self.spread_sma_1000.is_zero() {
             self.spread
         } else {
             self.spread_sma_1000 * dec!(0.999) + self.spread * dec!(0.001)
         };
-        self.spread_sma_1000.rescale(8);
+        // self.spread_sma_1000.rescale(8);
 
         while self.spread_vec.len() > 1_000 {
             self.spread_vec.remove(0);
@@ -353,8 +344,8 @@ impl Predictor {
             return;
         }
 
-        let is_open_long = self.spread_sma_1000 > self.params.open;
-        let is_open_short = self.spread_sma_1000 < self.params.open * Decimal::NEGATIVE_ONE;
+        let is_open_long = self.spread > self.params.open;
+        let is_open_short = self.spread < self.params.open * Decimal::NEGATIVE_ONE;
         let is_close_long = self.inventory > Decimal::ZERO;
         let is_close_short = self.inventory < Decimal::ZERO;
 
@@ -485,9 +476,9 @@ impl Predictor {
         let bid_price = self.bid_price;
         let last_price = self.last_price;
 
-        let spread = self.spread_sma;
-        let spread_max = self.spread_sma_2000;
-        let spread_min = self.spread_sma_1000;
+        let spread = self.spread_sma_1000 - self.spread_sma;
+        let spread_max = Self::UN_VIEW;
+        let spread_min = Self::UN_VIEW;
         // 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;

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