使用mid来开单

strategy/src/predictor.rs

@@ -52,15 +52,16 @@ pub struct Predictor {
     pub bid_delta: Decimal,                                                     // δb
 
     pub mid_price_time_vec: FixedTimeRangeDeque<Decimal>,                       // 中间价格队列，
+    pub mid_price_long_time_vec: FixedTimeRangeDeque<Decimal>,                  // 中间价格队列，
     pub fair_price_time_vec: FixedTimeRangeDeque<Decimal>,                      // 公平价格队列，
     pub fair_price_long_time_vec: FixedTimeRangeDeque<Decimal>,                 // 公平价格队列，
     pub fair_price_vec: Vec<Decimal>,                                           // 公平价格列表，0表示做市所，1表示参考所
     pub fair_price: Decimal,                                                    // 公平价格
     pub fair_price_ema_short: Decimal,                                          // 公平价格_ema
     pub fair_price_ema_long: Decimal,                                           // 公平价格_ema
-    pub fair_rate_focus_open: Decimal,                                          // 变化幅度焦点
+    pub mid_rate_focus_open: Decimal,                                          // 变化幅度焦点
     pub mid_price_focus_open: Decimal,                                          // 观测焦点时的价格
-    pub fair_rate_focus_close: Decimal,                                         // 变化幅度焦点
+    pub mid_rate_focus_close: Decimal,                                         // 变化幅度焦点
     pub fair_price_focus_close: Decimal,                                        // 观测焦点时的价格
     pub fair_price_when_ordering: Decimal,                                      // 下单时的公平价格
     pub price_times_avg: Decimal,                                               // 公平所与做市所的价格倍率的平均值
@@ -170,12 +171,13 @@ impl Predictor {
             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((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()),
+            mid_price_long_time_vec: FixedTimeRangeDeque::new((params.second_observation_time.to_f64().unwrap() * 1_000_000f64).to_i64().unwrap() * 2),
             fair_price: Default::default(),
             fair_price_ema_short: Default::default(),
             fair_price_ema_long: Default::default(),
-            fair_rate_focus_open: Default::default(),
+            mid_rate_focus_open: Default::default(),
             mid_price_focus_open: Default::default(),
-            fair_rate_focus_close: Default::default(),
+            mid_rate_focus_close: Default::default(),
             fair_price_focus_close: Default::default(),
             fair_price_when_ordering: Default::default(),
 
@@ -215,6 +217,7 @@ impl Predictor {
             self.mid_price = (self.ask_price + self.bid_price) / Decimal::TWO;
 
             self.mid_price_time_vec.push_back(self.mid_price);
+            self.mid_price_long_time_vec.push_back(self.mid_price);
 
             if !self.inventory.is_zero() {
                 let mut profit_now = if self.inventory > Decimal::ZERO {
@@ -386,59 +389,61 @@ impl Predictor {
                 return;
             }
 
-            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);
-            fair_long_rate.rescale(8);
-            let (mut mid_rate, mid_start) = Self::get_real_rate(&self.mid_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);
+            // fair_long_rate.rescale(8);
+            let (mut mid_rate, _) = Self::get_real_rate(&self.mid_price_time_vec);
             mid_rate.rescale(8);
+            let (mut mid_long_rate, _) = Self::get_real_rate(&self.mid_price_long_time_vec);
+            mid_long_rate.rescale(8);
 
             // 重置开仓焦点，条件1
-            if !self.fair_rate_focus_open.is_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 > Decimal::ZERO {
-                    self.fair_rate_focus_open = Decimal::ZERO;
-                }
-            }
+            // if !self.fair_rate_focus_open.is_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 > Decimal::ZERO {
+            //         self.fair_rate_focus_open = Decimal::ZERO;
+            //     }
+            // }
             // 重置开仓焦点，条件2
-            if !self.fair_rate_focus_open.is_zero() && !self.inventory.is_zero() {
-                self.fair_rate_focus_open = Decimal::ZERO;
+            if !self.mid_rate_focus_open.is_zero() && !self.inventory.is_zero() {
+                self.mid_rate_focus_open = Decimal::ZERO;
             }
             // 重置开仓焦点，条件3
             if !self.mid_price_focus_open.is_zero() {
                 let focus_rate = (self.mid_price - self.mid_price_focus_open) / self.mid_price_focus_open;
 
-                if self.fair_rate_focus_open < Decimal::ZERO && focus_rate < Decimal::NEGATIVE_ONE * self.params.open_activate / dec!(3) {
-                    self.fair_rate_focus_open = Decimal::ZERO;
+                if self.mid_rate_focus_open < Decimal::ZERO && focus_rate < Decimal::NEGATIVE_ONE * self.params.open_activate / dec!(3) {
+                    self.mid_rate_focus_open = Decimal::ZERO;
                 }
 
-                if self.fair_rate_focus_open > Decimal::ZERO && focus_rate > self.params.open_activate / dec!(3) {
-                    self.fair_rate_focus_open = Decimal::ZERO;
+                if self.mid_rate_focus_open > Decimal::ZERO && focus_rate > self.params.open_activate / dec!(3) {
+                    self.mid_rate_focus_open = Decimal::ZERO;
                 }
             }
             // 更新程序关注的开仓焦点
-            if self.fair_rate_focus_open.is_zero() && self.inventory.is_zero() {
+            if self.mid_rate_focus_open.is_zero() && self.inventory.is_zero() {
                 // 是同起点
-                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);
+                // 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;
+                // 最近80%的波动都发生在最近短周期的时间里
+                let is_high_speed = mid_rate.abs() > mid_long_rate.abs() * dec!(0.8) && mid_rate * mid_long_rate > Decimal::ZERO;
 
-                if is_cross && is_high_speed && self.spread_diff.abs() > self.params.min_spread {
+                if is_high_speed {
                     // 向上涨，并且fair下穿mid，视为观测阶段开始
-                    if mid_rate > Decimal::ZERO && fair_rate > Decimal::ZERO && self.spread_diff < Decimal::ZERO {
-                        self.fair_rate_focus_open = self.spread_diff;
+                    if mid_rate > Decimal::ZERO && mid_long_rate > Decimal::ZERO {
+                        self.mid_rate_focus_open = dec!(-0.01);
                         self.mid_price_focus_open = self.mid_price;
                     }
 
                     // 向下跌，并且fair上穿mid，视为观测阶段开始
-                    if mid_rate < Decimal::ZERO && fair_rate < Decimal::ZERO && self.spread_diff > Decimal::ZERO {
-                        self.fair_rate_focus_open = self.spread_diff;
+                    if mid_rate < Decimal::ZERO && mid_long_rate < Decimal::ZERO {
+                        self.mid_rate_focus_open = dec!(0.01);
                         self.mid_price_focus_open = self.mid_price;
                     }
                 }
@@ -450,8 +455,8 @@ impl Predictor {
             //  小于0：当前价格在均线之下
             // let close_rate = mid_rate.clone();
             // 重置平仓焦点，条件1
-            if !self.fair_rate_focus_close.is_zero() && self.inventory.is_zero() {
-                self.fair_rate_focus_close = Decimal::ZERO;
+            if !self.mid_rate_focus_close.is_zero() && self.inventory.is_zero() {
+                self.mid_rate_focus_close = Decimal::ZERO;
             }
             // 重置平仓焦点，条件2
             // if !self.fair_rate_focus_close.is_zero() && self.fair_rate_focus_close > dec!(-0.1) {
@@ -492,20 +497,20 @@ impl Predictor {
             // }
             // 15秒以后平仓
             let is_time_over = Utc::now().timestamp_micros() - self.prev_trade_time > 20 * 1_000_000;
-            if self.fair_rate_focus_close.is_zero() && !self.inventory.is_zero() && is_time_over {
+            if self.mid_rate_focus_close.is_zero() && !self.inventory.is_zero() && is_time_over {
                 if self.inventory > Decimal::ZERO {
-                    self.fair_rate_focus_close = dec!(0.01);
+                    self.mid_rate_focus_close = dec!(0.01);
                     self.fair_price_focus_close = self.mid_price;
                 }
                 if self.inventory < Decimal::ZERO {
-                    self.fair_rate_focus_close = dec!(-0.01);
+                    self.mid_rate_focus_close = dec!(-0.01);
                     self.fair_price_focus_close = self.mid_price;
                 }
             }
 
             // ============================ 平仓特殊逻辑处理1 =======================
-            if self.fair_rate_focus_close.is_zero() && !self.inventory.is_zero() && self.profit_point < dec!(-0.002) {
-                self.fair_rate_focus_close = dec!(-0.11);
+            if self.mid_rate_focus_close.is_zero() && !self.inventory.is_zero() && self.profit_point < dec!(-0.002) {
+                self.mid_rate_focus_close = dec!(-0.11);
                 self.fair_price_focus_close = self.mid_price;
 
                 // let prev_open_activate = self.params.open_activate;
@@ -517,12 +522,12 @@ impl Predictor {
                 info!("----------------------------------------");
             }
             // ============================ 平仓特殊逻辑处理2 =======================
-            if self.fair_rate_focus_close.is_zero() && !self.inventory.is_zero() && self.profit_point_vec.len() > 1 {
+            if self.mid_rate_focus_close.is_zero() && !self.inventory.is_zero() && self.profit_point_vec.len() > 1 {
                 let prev_profit_point = self.profit_point_vec[self.profit_point_vec.len() - 2];
                 let profit_point = self.profit_point_vec[self.profit_point_vec.len() - 1];
 
                 if (prev_profit_point >= Decimal::ZERO && profit_point < Decimal::ZERO) || (prev_profit_point > Decimal::ZERO && profit_point <= Decimal::ZERO) {
-                    self.fair_rate_focus_close = dec!(-0.12);
+                    self.mid_rate_focus_close = dec!(-0.12);
                     self.fair_price_focus_close = self.mid_price;
 
                     info!("----------------------------------------");
@@ -577,10 +582,10 @@ impl Predictor {
         // 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.fair_rate_focus_open > Decimal::ZERO;
-        let is_open_short = self.fair_rate_focus_open < Decimal::ZERO;
-        let is_close_long = self.inventory > Decimal::ZERO && (self.fair_rate_focus_close > Decimal::ZERO || self.fair_rate_focus_close < dec!(-0.1));
-        let is_close_short = self.inventory < Decimal::ZERO && (self.fair_rate_focus_close < Decimal::ZERO || self.fair_rate_focus_close < dec!(-0.1));
+        let is_open_long = self.mid_rate_focus_open > Decimal::ZERO;
+        let is_open_short = self.mid_rate_focus_open < Decimal::ZERO;
+        let is_close_long = self.inventory > Decimal::ZERO && (self.mid_rate_focus_close > Decimal::ZERO || self.mid_rate_focus_close < dec!(-0.1));
+        let is_close_short = self.inventory < Decimal::ZERO && (self.mid_rate_focus_close < Decimal::ZERO || self.mid_rate_focus_close < dec!(-0.1));
 
         self.bid_delta = dec!(-2);
         self.ask_delta = dec!(-2);
@@ -589,7 +594,7 @@ impl Predictor {
             // let close_rate = (self.error_rate / dec!(0.5)) * self.params.close;
             //
             // self.ask_delta = self.mid_price * close_rate;
-            if self.fair_rate_focus_close < dec!(-0.1) {
+            if self.mid_rate_focus_close < dec!(-0.1) {
                 self.ask_delta = dec!(-1);
             } else {
                 self.ask_delta = self.mid_price * self.params.close;
@@ -599,7 +604,7 @@ impl Predictor {
             //
             // self.bid_delta = self.mid_price * close_rate;
 
-            if self.fair_rate_focus_close < dec!(-0.1) {
+            if self.mid_rate_focus_close < dec!(-0.1) {
                 self.bid_delta = dec!(-1);
             } else {
                 self.bid_delta = self.mid_price * self.params.close;
@@ -716,7 +721,7 @@ impl Predictor {
         let ask_price = self.ask_price;
         let bid_price = self.bid_price;
         let last_price = self.last_price;
-        let fair_price = self.fair_price;
+        let fair_price = Self::DONT_VIEW;
 
         let spread = self.spread;
         let spread_max = self.spread_ema;
@@ -730,15 +735,15 @@ impl Predictor {
 
         let inventory = self.inventory;
 
-        let (sigma_square, _) = if self.fair_price_long_time_vec.len() > 1 {
-            Self::get_real_rate(&self.fair_price_long_time_vec)
+        let (sigma_square, _) = if self.mid_price_long_time_vec.len() > 1 {
+            Self::get_real_rate(&self.mid_price_long_time_vec)
         } else {
             (Decimal::ZERO, Decimal::ZERO)
         };
         // let sigma_square = self.error_rate;
 
-        let gamma = self.fair_rate_focus_open;
-        let kappa = self.fair_rate_focus_close;
+        let gamma = self.mid_rate_focus_open;
+        let kappa = self.mid_rate_focus_close;
 
         let flow_ratio = Decimal::ZERO;