趋势测试

strategy/src/predictor.rs

@@ -53,17 +53,17 @@ pub struct Predictor {
 
     pub mid_price_time_vec: FixedTimeRangeDeque<Decimal>,                       // 中间价格队列，
     pub mid_price_long_time_vec: FixedTimeRangeDeque<Decimal>,                  // 中间价格队列，
+    pub mid_price_trend_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 mid_rate_focus_open: Decimal,                                          // 变化幅度焦点
-    pub mid_price_focus_open: Decimal,                                          // 观测焦点时的价格
-    pub mid_rate_focus_close: Decimal,                                         // 变化幅度焦点
-    pub fair_price_focus_close: Decimal,                                        // 观测焦点时的价格
-    pub fair_price_when_ordering: Decimal,                                      // 下单时的公平价格
+    pub mid_rate_signal_open: Decimal,                                          // 变化幅度焦点
+    pub mid_price_focus_cancel: Decimal,                                        // 观测时定义的取消价格
+    pub mid_price_focus_stop_loss: Decimal,                                     // 观测时定义的止损价格
+    pub mid_rate_signal_close: Decimal,                                         // 变化幅度焦点
     pub price_times_avg: Decimal,                                               // 公平所与做市所的价格倍率的平均值
 
     pub is_ready: bool,                                                         // 是否已准备好
@@ -172,14 +172,14 @@ impl Predictor {
             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),
+            mid_price_trend_time_vec: FixedTimeRangeDeque::new(Self::TIME_DIFF_RANGE_MICROS),
             fair_price: Default::default(),
             fair_price_ema_short: Default::default(),
             fair_price_ema_long: Default::default(),
-            mid_rate_focus_open: Default::default(),
-            mid_price_focus_open: Default::default(),
-            mid_rate_focus_close: Default::default(),
-            fair_price_focus_close: Default::default(),
-            fair_price_when_ordering: Default::default(),
+            mid_rate_signal_open: Default::default(),
+            mid_price_focus_cancel: Default::default(),
+            mid_price_focus_stop_loss: Default::default(),
+            mid_rate_signal_close: Default::default(),
 
             price_times_avg: Default::default(),
 
@@ -218,6 +218,7 @@ impl Predictor {
 
             self.mid_price_time_vec.push_back(self.mid_price);
             self.mid_price_long_time_vec.push_back(self.mid_price);
+            self.mid_price_trend_time_vec.push_back(self.mid_price);
 
             if !self.inventory.is_zero() {
                 let mut profit_now = if self.inventory > Decimal::ZERO {
@@ -325,7 +326,7 @@ impl Predictor {
         self.processor().await;
     }
 
-    pub fn get_real_rate(price_vec: &FixedTimeRangeDeque<Decimal>) -> (Decimal, Decimal) {
+    pub fn get_real_rate(price_vec: &FixedTimeRangeDeque<Decimal>) -> (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();
@@ -333,9 +334,9 @@ impl Predictor {
         let down_rate = (max_price - last_fair_price) / max_price;
 
         if up_rate > down_rate {
-            (up_rate, min_price.clone())
+            (up_rate, min_price.clone(), max_price.clone())
         } else {
-            (-down_rate, max_price.clone())
+            (-down_rate, min_price.clone(), max_price.clone())
         }
     }
 
@@ -393,35 +394,28 @@ impl Predictor {
             // 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);
+            let (mut mid_rate, mid_min_price, mid_max_price) = 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);
+            let (mut mid_long_rate, _, _) = Self::get_real_rate(&self.mid_price_long_time_vec);
             mid_long_rate.rescale(8);
+            let (mut mid_trend_rate, _, _) = Self::get_real_rate(&self.mid_price_trend_time_vec);
+            mid_trend_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;
-            //     }
-            // }
-            // 重置开仓焦点，条件2
-            if !self.mid_rate_focus_open.is_zero() && !self.inventory.is_zero() {
-                self.mid_rate_focus_open = Decimal::ZERO;
+            if !self.mid_rate_signal_open.is_zero() && !self.inventory.is_zero() {
+                self.mid_rate_signal_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 focus_rate.abs() > self.params.open_activate / dec!(4) {
-                    self.mid_rate_focus_open = Decimal::ZERO;
+            // 重置开仓焦点，条件2
+            if !self.mid_price_focus_cancel.is_zero() {
+                if self.mid_rate_signal_open > Decimal::ZERO && self.mid_price > self.mid_price_focus_cancel {
+                    self.mid_rate_signal_open = Decimal::ZERO;
+                }
+                if self.mid_rate_signal_open < Decimal::ZERO && self.mid_price < self.mid_price_focus_cancel {
+                    self.mid_rate_signal_open = Decimal::ZERO;
                 }
             }
             // 更新程序关注的开仓焦点
-            if self.mid_rate_focus_open.is_zero() && self.inventory.is_zero() {
+            if self.mid_rate_signal_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;
@@ -430,17 +424,20 @@ impl Predictor {
                 // 最近80%的波动都发生在最近短周期的时间里
                 let is_high_speed = mid_rate.abs() > mid_long_rate.abs() * dec!(0.8) && mid_rate * mid_long_rate > Decimal::ZERO;
 
+                // mid_trend_rate防止追高
                 if is_high_speed && mid_rate.abs() > self.params.open_activate {
-                    // 向上涨，并且fair下穿mid，视为观测阶段开始
-                    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;
+                    // 向上涨，带量的，视为观测阶段开始
+                    if mid_rate > Decimal::ZERO && mid_long_rate > Decimal::ZERO && mid_trend_rate < Decimal::ZERO {
+                        self.mid_rate_signal_open = dec!(0.01);
+                        self.mid_price_focus_cancel = mid_max_price;
+                        self.mid_price_focus_stop_loss = mid_min_price;
                     }
 
-                    // 向下跌，并且fair上穿mid，视为观测阶段开始
-                    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;
+                    // 向下跌，带量的，视为观测阶段开始
+                    if mid_rate < Decimal::ZERO && mid_long_rate < Decimal::ZERO && mid_trend_rate > Decimal::ZERO {
+                        self.mid_rate_signal_open = dec!(-0.01);
+                        self.mid_price_focus_cancel = mid_min_price;
+                        self.mid_price_focus_stop_loss = mid_max_price;
                     }
                 }
             }
@@ -449,12 +446,11 @@ impl Predictor {
             // close_rate：
             //  大于0：当前价格在均线之上
             //  小于0：当前价格在均线之下
-            let close_rate = mid_rate.clone();
             // 重置平仓焦点，条件1
-            if !self.mid_rate_focus_close.is_zero() && self.inventory.is_zero() {
-                self.mid_rate_focus_close = Decimal::ZERO;
+            if !self.mid_rate_signal_close.is_zero() && self.inventory.is_zero() {
+                self.mid_rate_signal_close = Decimal::ZERO;
             }
-            // 重置平仓焦点，条件2
+            // // 重置平仓焦点，条件2
             // if !self.fair_rate_focus_close.is_zero() && self.fair_rate_focus_close > dec!(-0.1) {
             //     let focus_rate = (self.mid_price - self.fair_price_focus_close) / self.fair_price_focus_close;
             //
@@ -468,26 +464,22 @@ impl Predictor {
             // }
             // 更新程序关注的平仓焦点
             let close_activate = self.params.open_activate;
-            if self.mid_rate_focus_close.is_zero() && !self.inventory.is_zero() && close_rate.abs() > close_activate {
+            if self.mid_rate_signal_close.is_zero() && !self.inventory.is_zero() && mid_rate.abs() > close_activate {
                 // 多单平仓逻辑
-                if self.inventory > Decimal::ZERO && close_rate > Decimal::ZERO {
+                if self.inventory > Decimal::ZERO && mid_rate > Decimal::ZERO {
                     if self.profit_point > Decimal::ZERO {
-                        self.mid_rate_focus_close = close_rate;
-                        self.fair_price_focus_close = self.mid_price;
+                        self.mid_rate_signal_close = mid_rate;
                     } else if self.t_diff.is_zero() {
-                        self.mid_rate_focus_close = close_rate;
-                        self.fair_price_focus_close = self.mid_price;
+                        self.mid_rate_signal_close = mid_rate;
                     }
                 }
 
                 // 空单平仓逻辑
-                if self.inventory < Decimal::ZERO && close_rate < Decimal::ZERO {
+                if self.inventory < Decimal::ZERO && mid_rate < Decimal::ZERO {
                     if self.profit_point > Decimal::ZERO {
-                        self.mid_rate_focus_close = close_rate;
-                        self.fair_price_focus_close = self.fair_price;
+                        self.mid_rate_signal_close = mid_rate;
                     } else if self.t_diff.is_zero() {
-                        self.mid_rate_focus_close = close_rate;
-                        self.fair_price_focus_close = self.fair_price;
+                        self.mid_rate_signal_close = mid_rate;
                     }
                 }
             }
@@ -505,7 +497,7 @@ impl Predictor {
             // }
 
             // ============================ 平仓特殊逻辑处理1 =======================
-            // if self.mid_rate_focus_close.is_zero() && !self.inventory.is_zero() && self.profit_point < dec!(-0.002) {
+            // if self.mid_rate_focus_close.is_zero() && !self.inventory.is_zero() && self.profit_point < dec!(-0.02) {
             //     self.mid_rate_focus_close = dec!(-0.11);
             //     self.fair_price_focus_close = self.mid_price;
             //
@@ -518,19 +510,36 @@ impl Predictor {
             //     info!("----------------------------------------");
             // }
             // ============================ 平仓特殊逻辑处理2 =======================
-            if self.mid_rate_focus_close.is_zero() && !self.inventory.is_zero() && self.profit_point_vec.len() > 1 {
+            if self.mid_rate_signal_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.mid_rate_focus_close = dec!(-0.12);
-                    self.fair_price_focus_close = self.mid_price;
+                    self.mid_rate_signal_close = dec!(-0.12);
 
                     info!("----------------------------------------");
-                    info!("止损逻辑2, 在价格{}处，成本价{}，价值={}, p={}。", self.fair_price_focus_close, self.pos_avg_price, self.pos_avg_price*self.pos_amount, self.profit_point);
+                    info!("止损逻辑2, 在价格{}处，成本价{}，价值={}, p={}。", self.mid_price, self.pos_avg_price, self.pos_avg_price*self.pos_amount, self.profit_point);
                     info!("----------------------------------------");
                 }
             }
+            // ============================ 平仓特殊逻辑处理3 =======================
+            // if self.mid_rate_signal_close.is_zero() && !self.inventory.is_zero() {
+            //     if self.inventory > Decimal::ZERO && self.mid_price < self.mid_price_focus_stop_loss {
+            //         self.mid_rate_signal_close = dec!(-0.13);
+            //
+            //         info!("----------------------------------------");
+            //         // info!("止损，参数调整：{} -> {}", prev_open_activate, self.params.open_activate);
+            //         info!("趋势失效止损, 在价格{}处，成本价{}，价值={}, p={}。", self.mid_price, self.pos_avg_price, self.pos_avg_price*self.pos_amount, self.profit_point);
+            //         info!("----------------------------------------");
+            //     } else if self.inventory < Decimal::ZERO && self.mid_price > self.mid_price_focus_stop_loss {
+            //         self.mid_rate_signal_close = dec!(-0.13);
+            //
+            //         info!("----------------------------------------");
+            //         // info!("止损，参数调整：{} -> {}", prev_open_activate, self.params.open_activate);
+            //         info!("趋势失效止损, 在价格{}处，成本价{}，价值={}, p={}。", self.mid_price, self.pos_avg_price, self.pos_avg_price*self.pos_amount, self.profit_point);
+            //         info!("----------------------------------------");
+            //     }
+            // }
         }
 
         // // 判断价格是否回归
@@ -578,10 +587,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.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));
+        let is_open_long = self.mid_rate_signal_open > Decimal::ZERO;
+        let is_open_short = self.mid_rate_signal_open < Decimal::ZERO;
+        let is_close_long = self.inventory > Decimal::ZERO && (self.mid_rate_signal_close > Decimal::ZERO || self.mid_rate_signal_close < dec!(-0.1));
+        let is_close_short = self.inventory < Decimal::ZERO && (self.mid_rate_signal_close < Decimal::ZERO || self.mid_rate_signal_close < dec!(-0.1));
 
         self.bid_delta = dec!(-2);
         self.ask_delta = dec!(-2);
@@ -590,7 +599,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.mid_rate_focus_close < dec!(-0.1) {
+            if self.mid_rate_signal_close < dec!(-0.1) {
                 self.ask_delta = dec!(-1);
             } else {
                 self.ask_delta = self.mid_price * self.params.close;
@@ -600,7 +609,7 @@ impl Predictor {
             //
             // self.bid_delta = self.mid_price * close_rate;
 
-            if self.mid_rate_focus_close < dec!(-0.1) {
+            if self.mid_rate_signal_close < dec!(-0.1) {
                 self.bid_delta = dec!(-1);
             } else {
                 self.bid_delta = self.mid_price * self.params.close;
@@ -719,9 +728,9 @@ impl Predictor {
         let last_price = self.last_price;
         let fair_price = Self::DONT_VIEW;
 
-        let spread = self.spread;
-        let spread_max = self.spread_ema;
-        let spread_min = self.spread_diff;
+        let spread = self.mid_price;
+        let spread_max = self.mid_price_focus_cancel;
+        let spread_min = self.mid_price_focus_stop_loss;
         // 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;
@@ -731,15 +740,15 @@ impl Predictor {
 
         let inventory = self.inventory;
 
-        let (sigma_square, _) = if self.mid_price_long_time_vec.len() > 1 {
-            Self::get_real_rate(&self.mid_price_long_time_vec)
+        let (sigma_square, _, _) = if self.mid_price_trend_time_vec.len() > 1 {
+            Self::get_real_rate(&self.mid_price_trend_time_vec)
         } else {
-            (Decimal::ZERO, Decimal::ZERO)
+            (Decimal::ZERO, Decimal::ZERO, Decimal::ZERO)
         };
         // let sigma_square = self.error_rate;
 
-        let gamma = self.mid_rate_focus_open;
-        let kappa = self.mid_rate_focus_close;
+        let gamma = self.mid_rate_signal_open;
+        let kappa = self.mid_rate_signal_close;
 
         let flow_ratio = Decimal::ZERO;
 

strategy/src/strategy.rs

@@ -999,7 +999,7 @@ impl Strategy {
             // 下单价值判定
             let amount_value = amount * target_buy_price;
             if amount_value >= self.min_amount_value || predictor.inventory < Decimal::ZERO {
-                predictor.fair_price_when_ordering = predictor.fair_price.clone();
+                // predictor.fair_price_when_ordering = predictor.fair_price.clone();
 
                 let client_id = utils::generate_client_id(Some(self.broker_id.clone()));
                 let order = vec![
@@ -1032,7 +1032,7 @@ impl Strategy {
             // 下单价值不能太大，也不能太小
             let amount_value = amount * target_sell_price;
             if amount_value >= self.min_amount_value || predictor.inventory > Decimal::ZERO {
-                predictor.fair_price_when_ordering = predictor.fair_price.clone();
+                // predictor.fair_price_when_ordering = predictor.fair_price.clone();
 
                 let client_id = utils::generate_client_id(Some(self.broker_id.clone()));
                 let order = vec![