剩个kappa没搞出来。

strategy/src/predictor.rs

@@ -33,8 +33,8 @@ impl<T> FixedLengthDeque<T> {
         self.deque.len()
     }
 
-    pub fn get(&self) -> &VecDeque<T> {
-        &self.deque
+    pub fn get(&self, index: usize) -> Option<&T> {
+        self.deque.get(index)
     }
 }
 
@@ -63,14 +63,14 @@ pub struct AvellanedaStoikov {
 
     pub inventory_vec: FixedLengthDeque<Decimal>,
     pub gamma_vec: FixedLengthDeque<Decimal>,
-    pub sigma_vec: FixedLengthDeque<Decimal>,
+    pub sigma_square_vec: FixedLengthDeque<Decimal>,
     pub delta_plus_vec: FixedLengthDeque<Decimal>,
     pub kappa_vec: FixedLengthDeque<Decimal>,
     pub ref_price_vec: FixedLengthDeque<Decimal>,
 
     pub inventory: Decimal,                                                     // 库存，也就是q
     pub gamma: Decimal,                                                         // γ，库存风险厌恶参数
-    pub sigma: Decimal,                                                         // σ，波动性
+    pub sigma_square: Decimal,                                                  // σ^2，波动性的平方
     pub delta_plus: Decimal,                                                    // δa+δb，买卖挂单间距
     pub kappa: Decimal,                                                         // κ 订单簿 流动性 参数
     pub ref_price: Decimal,                                                     // 预定价格
@@ -107,14 +107,14 @@ impl AvellanedaStoikov {
 
             inventory_vec: FixedLengthDeque::new(MAX_DATA_LENGTH),
             gamma_vec: FixedLengthDeque::new(MAX_DATA_LENGTH),
-            sigma_vec: FixedLengthDeque::new(MAX_DATA_LENGTH),
+            sigma_square_vec: FixedLengthDeque::new(MAX_DATA_LENGTH),
             delta_plus_vec: FixedLengthDeque::new(MAX_DATA_LENGTH),
             kappa_vec: FixedLengthDeque::new(MAX_DATA_LENGTH),
             ref_price_vec: FixedLengthDeque::new(MAX_DATA_LENGTH),
 
             inventory: Default::default(),
             gamma: Default::default(),
-            sigma: Default::default(),
+            sigma_square: Default::default(),
             delta_plus: Default::default(),
             kappa: Default::default(),
             ref_price: Default::default(),
@@ -186,11 +186,59 @@ impl AvellanedaStoikov {
         self.inventory_vec.push_back(inventory)
     }
 
+    pub fn update_sigma_square(&mut self) {
+        self.sigma_square = if self.trade_vec.len() < 2 {
+            Decimal::ZERO
+        } else {
+            let first_trade = self.trade_vec.get(0).unwrap();
+            let last_trade = self.trade_vec.get(self.trade_vec.len() - 1).unwrap();
+
+            let time_diff = (last_trade.time - first_trade.time) / Decimal::ONE_THOUSAND;
+            let mut vol_square_total = Decimal::ZERO;
+            for (index, trade) in self.trade_vec.deque.iter().enumerate() {
+                if index == 0 {
+                    continue
+                }
+
+                let prev_trade = self.trade_vec.get(index - 1).unwrap();
+                let vol_square = (trade.price - prev_trade.price).powd(Decimal::TWO);
+                vol_square_total += vol_square;
+            }
+
+            if time_diff == Decimal::ZERO {
+                Decimal::ZERO
+            } else {
+                (Decimal::ONE / time_diff) * vol_square_total
+            }
+        };
+
+        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
+        } else {
+            const IRA: Decimal = Decimal::ONE;
+
+            IRA * (self.spread_max - self.spread_min) / (Decimal::TWO * self.inventory.abs() * self.sigma_square)
+        };
+
+        self.gamma_vec.push_back(self.gamma);
+    }
+
+    pub fn update_kappa(&mut self) {
+        self.kappa = Decimal::ZERO;
+        // 明天来搞kappa
+    }
+
     // #[instrument(skip(self), level="TRACE")]
     fn processor(&mut self) {
+        self.update_sigma_square();
+        self.update_gamma();
         self.update_ref_price();
 
-        info!("{}, {}", self.mid_price, self.spread_max);
+        info!("{}, {}, {}", self.spread_max, self.gamma, self.sigma_square);
     }
 
     // #[instrument(skip(self, ref_ticker_map), level="TRACE")]