v1.1.0: 用多个参考所进行判断

global/src/params.rs

@@ -94,7 +94,7 @@ impl Params {
             pair: json_value["pair"].as_str().unwrap().to_string(),
             open: Decimal::try_from(json_value["open"].as_f64().unwrap_or_default()).unwrap(),
             open_activate: Decimal::try_from(json_value["open_activate"].as_f64().unwrap_or_default()).unwrap(),
-            min_spread: Decimal::try_from(json_value["min_spread"].as_f64().unwrap_or_default()).unwrap(),
+            min_spread: Decimal::try_from(json_value["min_spread"].as_f64().unwrap()).unwrap(),
             close: Decimal::try_from(json_value["close"].as_f64().unwrap_or_default()).unwrap(),
             second_observation_time: Decimal::try_from(json_value["second_observation_time"].as_f64().unwrap()).unwrap(),
             lever_rate: Decimal::try_from(json_value["lever_rate"].as_f64().unwrap_or_default()).unwrap(),

strategy/src/predictor.rs

@@ -324,131 +324,64 @@ impl Predictor {
         // 合成公平价格
         self.fair_price_std_vec[index] = self.fair_price_vec[index] / self.price_avg_times_vec[index];
 
-        // 合成公平价格
-        if !self.fair_price_std_vec[0].is_zero() && !self.fair_price_std_vec[1].is_zero() {
-            if self.fair_price_time_vec.len() < 2 {
+        // 开仓信号处理
+        let mut signal = Decimal::ZERO;
+        for fair_price_std in &self.fair_price_std_vec {
+            if fair_price_std.is_zero() {
                 return;
             }
 
-            let mut rate = Self::get_real_rate(&self.fair_price_time_vec);
-            rate.rescale(8);
-
-            // 重置开仓焦点，条件1
-            if !self.fair_rate_focus_open.is_zero() && !self.inventory.is_zero() {
-                self.fair_rate_focus_open = Decimal::ZERO;
-            }
-            // 重置开仓焦点，条件2
-            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.fair_rate_focus_open < Decimal::ZERO && focus_rate > self.params.open_activate / dec!(3) {
-                    self.fair_rate_focus_open = Decimal::ZERO;
-                }
-            }
-            // 更新程序关注的开仓焦点
-            if self.fair_rate_focus_open.is_zero() && self.inventory.is_zero() {
-                // 只有有强度的rate才有资格被称为针，并且差价够大，
-                if rate.abs() > self.params.open_activate {
-                    // 向上涨，并且fair下穿mid，视为观测阶段开始
-                    if rate > Decimal::ZERO {
-                        self.fair_rate_focus_open = rate;
-                        self.mid_price_focus_open = self.mid_price;
-                    }
+            self.spread_vec[index] = fair_price_std - self.mid_price;
 
-                    // 向下跌，并且fair上穿mid，视为观测阶段开始
-                    if rate < Decimal::ZERO {
-                        self.fair_rate_focus_open = rate;
-                        self.mid_price_focus_open = self.mid_price;
-                    }
-                }
+            if self.spread_vec[index] > self.params.min_spread {
+                signal = signal + Decimal::ONE;
             }
-
-            // ============================ 平仓逻辑处理 =======================
-            // close_rate：
-            //  大于0：当前价格在均线之上
-            //  小于0：当前价格在均线之下
-            let close_rate = rate.clone();
-            // 重置平仓焦点，条件1
-            if !self.fair_rate_focus_close.is_zero() && self.inventory.is_zero() {
-                self.fair_rate_focus_close = Decimal::ZERO;
+            if self.spread_vec[index] < -self.params.min_spread {
+                signal = signal - Decimal::ONE;
             }
-            // 重置平仓焦点，条件2
-            if !self.fair_rate_focus_close.is_zero() && self.fair_rate_focus_close > dec!(-0.1) {
-                let focus_rate = (self.mid_price - self.mid_price_focus_close) / self.mid_price_focus_close;
+        }
 
-                if self.fair_rate_focus_close > Decimal::ZERO && focus_rate < Decimal::NEGATIVE_ONE * self.params.close_activate / Decimal::TWO {
-                    self.fair_rate_focus_close = Decimal::ZERO;
+        // 重置开仓焦点，条件1
+        if !self.fair_rate_focus_open.is_zero() && !self.inventory.is_zero() {
+            self.fair_rate_focus_open = Decimal::ZERO;
+        }
+        // 重置开仓焦点，条件2
+        if !self.fair_rate_focus_open.is_zero() && signal.abs() < Decimal::from(self.params.ref_exchange.len()) {
+            self.fair_rate_focus_open = Decimal::ZERO;
+        }
+        // 更新程序关注的开仓焦点
+        if self.fair_rate_focus_open.is_zero() && self.inventory.is_zero() {
+            // 只有有强度的rate才有资格被称为针，并且差价够大，
+            if signal.abs() == Decimal::from(self.params.ref_exchange.len()) {
+                if signal > Decimal::ZERO {
+                    self.fair_rate_focus_open = dec!(0.01);
+                    self.mid_price_focus_open = self.mid_price;
                 }
 
-                if self.fair_rate_focus_close < Decimal::ZERO && focus_rate > self.params.close_activate / Decimal::TWO {
-                    self.fair_rate_focus_close = Decimal::ZERO;
+                if signal < Decimal::ZERO {
+                    self.fair_rate_focus_open = dec!(-0.01);
+                    self.mid_price_focus_open = self.mid_price;
                 }
             }
-            // 更新程序关注的平仓焦点
-            let close_activate = self.params.open_activate;
-            if self.fair_rate_focus_close.is_zero() && !self.inventory.is_zero() && close_rate.abs() > close_activate {
-                // 多单平仓逻辑
-                if self.inventory > Decimal::ZERO && close_rate > Decimal::ZERO {
-                    if self.profit_point > Decimal::ZERO {
-                        self.fair_rate_focus_close = close_rate;
-                        self.mid_price_focus_close = self.mid_price;
-                    } else if self.t_diff.is_zero() {
-                        self.fair_rate_focus_close = close_rate;
-                        self.mid_price_focus_close = self.mid_price;
-                    }
-                }
+        }
 
-                // 空单平仓逻辑
-                if self.inventory < Decimal::ZERO && close_rate < Decimal::ZERO {
-                    if self.profit_point > Decimal::ZERO {
-                        self.fair_rate_focus_close = close_rate;
-                        self.mid_price_focus_close = self.mid_price;
-                    } else if self.t_diff.is_zero() {
-                        self.fair_rate_focus_close = close_rate;
-                        self.mid_price_focus_close = self.mid_price;
-                    }
-                }
+        // ============================ 平仓逻辑处理 =======================
+        // 重置平仓焦点，条件1
+        if !self.fair_rate_focus_close.is_zero() && self.inventory.is_zero() {
+            self.fair_rate_focus_close = Decimal::ZERO;
+        }
+        // 更新程序关注的平仓焦点
+        if self.fair_rate_focus_close.is_zero() && !self.inventory.is_zero() {
+            if self.inventory > Decimal::ZERO {
+                self.fair_rate_focus_close = dec!(0.01);
+                self.mid_price_focus_close = self.mid_price;
             }
 
-            // ============================ 平仓特殊逻辑处理1 =======================
-            // if self.fair_rate_focus_close.is_zero() && !self.inventory.is_zero() && self.profit_point < dec!(-0.01) {
-            //     self.fair_rate_focus_close = dec!(-0.11);
-            //     self.fair_price_focus_close = self.mid_price;
-            //
-            //     // let prev_open_activate = self.params.open_activate;
-            //     // self.params.open_activate = self.params.open_activate * dec!(1.5);
-            //
-            //     info!("----------------------------------------");
-            //     // info!("止损，参数调整：{} -> {}", prev_open_activate, self.params.open_activate);
-            //     info!("硬止损, 在价格{}处，成本价{}，价值={}, p={}。", self.fair_price_focus_close, self.pos_avg_price, self.pos_avg_price*self.pos_amount, self.profit_point);
-            //     info!("----------------------------------------");
-            // }
-            // ============================ 平仓特殊逻辑处理2 =======================
-            if self.fair_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_price_focus_close = self.mid_price;
-
-                    info!("----------------------------------------");
-                    info!("止损逻辑2, 在价格{}处，成本价{}，价值={}, p={}。", self.mid_price_focus_close, self.pos_avg_price, self.pos_avg_price*self.pos_amount, self.profit_point);
-                    info!("----------------------------------------");
-                }
+            if self.inventory < Decimal::ZERO {
+                self.fair_rate_focus_close = dec!(-0.01);
+                self.mid_price_focus_close = self.mid_price;
             }
         }
-
-        // // 判断价格是否回归
-        // 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.spread_sma_1000 > min(self.spread_sma, self.spread_sma_2000) {
-        //     self.is_regressed = true
-        // }
     }
 
     pub fn update_spread(&mut self) {
@@ -486,8 +419,8 @@ 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_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));