所有变量都已就绪。

standard/src/gate_swap.rs

@@ -143,7 +143,7 @@ impl Platform for GateSwap {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let res_data = self.request.get_user_position(symbol_array[1].to_string().to_lowercase()).await;
         if res_data.code == 200 {
-            info!("{}", res_data.data.to_string());
+            // info!("{}", res_data.data.to_string());
             let res_data_json = res_data.data.as_array().unwrap();
             let result = res_data_json.iter().map(|item| { format_position_item(item, Decimal::ONE) }).collect();
             Ok(result)

strategy/src/predictor.rs

@@ -62,17 +62,17 @@ pub struct AvellanedaStoikov {
     pub optimal_bid_price: Decimal,                                             // 买入价挂单
 
     pub inventory_vec: FixedLengthDeque<Decimal>,
-    pub gamma_vec: FixedLengthDeque<Decimal>,
     pub sigma_square_vec: FixedLengthDeque<Decimal>,
-    pub delta_plus_vec: FixedLengthDeque<Decimal>,
+    pub gamma_vec: FixedLengthDeque<Decimal>,
     pub kappa_vec: FixedLengthDeque<Decimal>,
+    pub delta_plus_vec: FixedLengthDeque<Decimal>,
     pub ref_price_vec: FixedLengthDeque<Decimal>,
 
     pub inventory: Decimal,                                                     // 库存，也就是q
-    pub gamma: Decimal,                                                         // γ，库存风险厌恶参数
     pub sigma_square: Decimal,                                                  // σ^2，波动性的平方
-    pub delta_plus: Decimal,                                                    // δa+δb，买卖挂单间距
+    pub gamma: Decimal,                                                         // γ，库存风险厌恶参数
     pub kappa: Decimal,                                                         // κ 订单簿 流动性 参数
+    pub delta_plus: Decimal,                                                    // δa+δb，买卖挂单间距
     pub ref_price: Decimal,                                                     // 预定价格
 }
 
@@ -154,11 +154,6 @@ impl AvellanedaStoikov {
         }
     }
 
-    pub fn update_ref_price(&mut self) {
-        self.ref_price = self.mid_price;
-        self.ref_price_vec.push_back(self.ref_price);
-    }
-
     pub fn on_depth(&mut self, depth: &Depth) {
         self.depth_vec.push_back(depth.clone());
 
@@ -212,33 +207,59 @@ impl AvellanedaStoikov {
             }
         };
 
+        self.sigma_square.rescale(10);
         self.sigma_square_vec.push_back(self.sigma_square);
     }
 
     pub fn update_gamma(&mut self) {
         self.gamma = if self.sigma_square == Decimal::ZERO || self.inventory == Decimal::ZERO {
-            Decimal::ZERO
+            Decimal::ONE
         } else {
             const IRA: Decimal = Decimal::ONE;
 
             IRA * (self.spread_max - self.spread_min) / (Decimal::TWO * self.inventory.abs() * self.sigma_square)
         };
-
+        self.gamma.rescale(8);
         self.gamma_vec.push_back(self.gamma);
     }
 
     pub fn update_kappa(&mut self) {
-        self.kappa = Decimal::ZERO;
-        // 明天来搞kappa
+        let temp = (self.spread_max - self.spread_min) * self.gamma - self.sigma_square * self.gamma.powd(Decimal::TWO);
+        self.kappa = if temp == Decimal::ZERO {
+            Decimal::ZERO
+        } else {
+            self.gamma / (temp.exp() - Decimal::ONE)
+        };
+        self.kappa.rescale(8);
+        self.kappa_vec.push_back(self.kappa);
+    }
+
+    pub fn update_ref_price(&mut self) {
+        self.ref_price = self.mid_price - self.inventory * self.gamma * self.sigma_square;
+        self.ref_price_vec.push_back(self.ref_price);
+    }
+
+    pub fn update_delta_plus(&mut self) {
+        self.delta_plus = if self.gamma == Decimal::ZERO || self.kappa == Decimal::ZERO {
+            Decimal::ZERO
+        } else {
+            let left_value = self.gamma * self.sigma_square;
+            let right_value = (Decimal::TWO / self.gamma) * (Decimal::ONE + self.gamma / self.kappa).ln();
+            left_value + right_value
+        };
+        self.delta_plus.rescale(8);
+        self.delta_plus_vec.push_back(self.delta_plus);
     }
 
     // #[instrument(skip(self), level="TRACE")]
     fn processor(&mut self) {
         self.update_sigma_square();
         self.update_gamma();
+        self.update_kappa();
         self.update_ref_price();
+        self.update_delta_plus();
 
-        info!("{}, {}, {}", self.spread_max, self.gamma, self.sigma_square);
+        info!(?self.spread_max, ?self.gamma, ?self.sigma_square, ?self.kappa, ?self.ref_price, ?self.delta_plus);
     }
 
     // #[instrument(skip(self, ref_ticker_map), level="TRACE")]