平仓优化，版本1

global/src/params.rs

@@ -24,8 +24,10 @@ pub struct Params {
     pub pair: String,
     // 开仓
     pub open: Decimal,
-    // 激活挂单
+    // 激活开仓挂单
     pub open_activate: Decimal,
+    // 激活平仓挂单
+    pub close_activate: Decimal,
     // 平仓
     pub close: Decimal,
     // 杠杆大小
@@ -88,6 +90,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(),
+            close_activate: Decimal::try_from(json_value["close_activate"].as_f64().unwrap_or_default()).unwrap(),
             close: Decimal::try_from(json_value["close"].as_f64().unwrap_or_default()).unwrap(),
             lever_rate: Decimal::try_from(json_value["lever_rate"].as_f64().unwrap_or_default()).unwrap(),
             hold_coin: Decimal::try_from(json_value["hold_coin"].as_f64().unwrap_or_default()).unwrap(),

strategy/src/predictor.rs

@@ -50,8 +50,9 @@ pub struct Predictor {
     pub spread_sma_1000_time_vec: FixedTimeRangeDeque<Decimal>,                 // spread队列，10ms以内的所有spread_sma_1000
     pub fair_price_vec: Vec<Decimal>,                                           // 公平价格列表，0表示做市所，1表示参考所
     pub fair_price: Decimal,                                                    // 预定价格
-    pub fair_rate_focus: Decimal,                                               // 变化幅度焦点
-    pub fair_price_focus: Decimal,                                              // 观测焦点时的价格
+    pub fair_rate_focus_open: Decimal,                                          // 变化幅度焦点
+    pub fair_rate_focus_close: Decimal,                                          // 变化幅度焦点
+    pub fair_price_focus_open: Decimal,                                         // 观测焦点时的价格
     pub fair_price_when_ordering: Decimal,                                      // 下单时的预定价格
     pub price_times_avg: Decimal,                                               // 公平所与做市所的价格倍率的平均值
     pub is_regressed: bool,                                                     // 做市所的价格是否已经回归
@@ -163,8 +164,9 @@ impl Predictor {
             fair_price_time_vec: FixedTimeRangeDeque::new(10_000_000),
             mid_price_time_vec: FixedTimeRangeDeque::new(100_000),
             fair_price: Default::default(),
-            fair_rate_focus: Default::default(),
-            fair_price_focus: Default::default(),
+            fair_rate_focus_open: Default::default(),
+            fair_rate_focus_close: Default::default(),
+            fair_price_focus_open: Default::default(),
             fair_price_when_ordering: Default::default(),
 
             price_times_avg: Default::default(),
@@ -323,49 +325,66 @@ impl Predictor {
             let mut rate = (last_fair_price - first_fair_price) / first_fair_price;
             rate.rescale(8);
 
-            // 重置焦点，条件1
-            if !self.fair_rate_focus.is_zero() {
+            // 重置开仓焦点，条件1
+            if !self.fair_rate_focus_open.is_zero() {
                 // 向上涨，并且mid下穿fair，视为观测阶段结束
-                if self.fair_rate_focus > Decimal::ZERO && self.spread_sma_1000 < Decimal::ZERO {
-                    self.fair_rate_focus = Decimal::ZERO;
+                if self.fair_rate_focus_open > Decimal::ZERO && self.spread_sma_1000 < Decimal::ZERO {
+                    self.fair_rate_focus_open = Decimal::ZERO;
                 }
 
                 // 向下跌，并且mid上穿fair，视为观测阶段结束
-                if self.fair_rate_focus < Decimal::ZERO && self.spread_sma_1000 > Decimal::ZERO {
-                    self.fair_rate_focus = Decimal::ZERO;
+                if self.fair_rate_focus_open < Decimal::ZERO && self.spread_sma_1000 > Decimal::ZERO {
+                    self.fair_rate_focus_open = Decimal::ZERO;
                 }
             }
-            // 重置焦点，条件2
-            if !self.fair_rate_focus.is_zero() && !self.inventory.is_zero() {
-                self.fair_rate_focus = Decimal::ZERO;
+            // 重置开仓焦点，条件2
+            if !self.fair_rate_focus_open.is_zero() && !self.inventory.is_zero() {
+                self.fair_rate_focus_open = Decimal::ZERO;
             }
-            // 重置焦点，条件3
-            if !self.fair_price_focus.is_zero() {
-                let focus_rate = (self.fair_price - self.fair_price_focus) / self.fair_price_focus;
+            // 重置开仓焦点，条件3
+            if !self.fair_price_focus_open.is_zero() {
+                let focus_rate = (self.fair_price - self.fair_price_focus_open) / self.fair_price_focus_open;
 
-                if self.fair_rate_focus > Decimal::ZERO && focus_rate < Decimal::NEGATIVE_ONE * self.params.open_activate / Decimal::TWO {
-                    self.fair_rate_focus = Decimal::ZERO;
+                if self.fair_rate_focus_open > Decimal::ZERO && focus_rate < Decimal::NEGATIVE_ONE * self.params.open_activate / Decimal::TWO {
+                    self.fair_rate_focus_open = Decimal::ZERO;
                 }
 
-                if self.fair_rate_focus < Decimal::ZERO && focus_rate > self.params.open_activate / Decimal::TWO {
-                    self.fair_rate_focus = Decimal::ZERO;
+                if self.fair_rate_focus_open < Decimal::ZERO && focus_rate > self.params.open_activate / Decimal::TWO {
+                    self.fair_rate_focus_open = Decimal::ZERO;
                 }
             }
-
-            // 更新程序关注的变化幅度焦点
-            if self.fair_rate_focus.is_zero() && self.inventory.is_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 = rate;
-                        self.fair_price_focus = self.fair_price;
+                        self.fair_rate_focus_open = rate;
+                        self.fair_price_focus_open = self.fair_price;
                     }
 
                     // 向下跌，并且fair上穿mid，视为观测阶段开始
                     if rate < Decimal::ZERO {
-                        self.fair_rate_focus = rate;
-                        self.fair_price_focus = self.fair_price;
+                        self.fair_rate_focus_open = rate;
+                        self.fair_price_focus_open = self.fair_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() {
+                // 只有有强度的rate才有资格被称为针
+                if rate.abs() > self.params.close_activate {
+                    if self.inventory > Decimal::ZERO && rate < Decimal::ZERO {
+                        self.fair_rate_focus_close = rate;
+                    }
+
+                    if self.inventory < Decimal::ZERO && rate > Decimal::ZERO {
+                        self.fair_rate_focus_close = rate;
                     }
                 }
             }
@@ -428,10 +447,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 < Decimal::ZERO && self.fair_price > self.mid_price;
-        let is_open_short = self.fair_rate_focus > Decimal::ZERO && self.fair_price < self.mid_price;
-        let is_close_long = self.inventory > Decimal::ZERO;
-        let is_close_short = self.inventory < Decimal::ZERO;
+        let is_open_long = self.fair_rate_focus_open < Decimal::ZERO && self.fair_price > self.mid_price;
+        let is_open_short = self.fair_rate_focus_open > Decimal::ZERO && self.fair_price < self.mid_price;
+        let is_close_long = self.inventory > Decimal::ZERO && self.fair_rate_focus_close > Decimal::ZERO;
+        let is_close_short = self.inventory < Decimal::ZERO && self.fair_rate_focus_close < Decimal::ZERO;
 
         self.bid_delta = dec!(-2);
         self.ask_delta = dec!(-2);
@@ -580,17 +599,20 @@ impl Predictor {
 
         let inventory = self.inventory;
 
-        let sigma_square = if self.fair_price_time_vec.len() > 1 {
-            let last_fair_price = self.fair_price_time_vec.deque.iter().last().unwrap();
-            let first_fair_price = self.fair_price_time_vec.deque[0];
-            (last_fair_price - first_fair_price) / first_fair_price
-        } else {
-            Decimal::ZERO
-        };
+        // // 这个是过去一段时间的价格变化幅度显示
+        // let sigma_square = if self.fair_price_time_vec.len() > 1 {
+        //     let last_fair_price = self.fair_price_time_vec.deque.iter().last().unwrap();
+        //     let first_fair_price = self.fair_price_time_vec.deque[0];
+        //     (last_fair_price - first_fair_price) / first_fair_price
+        // } else {
+        //     Decimal::ZERO
+        // };
+
+        let sigma_square = self.error_rate;
 
-        let gamma = self.error_rate;
+        let gamma = self.fair_rate_focus_open;
 
-        let kappa = self.fair_rate_focus;
+        let kappa = self.fair_rate_focus_close;
 
         let flow_ratio = Decimal::ZERO;
         let ref_price = self.fair_price;