sigma和mu

strategy/src/predictor.rs

@@ -21,10 +21,12 @@ pub struct Predictor {
 
     // 做市所的计算
     pub close_price_vec: FixedTimeRangeDeque<Record>,
+    pub log_return_vec: VecDeque<Decimal>,
+    pub r_vec: VecDeque<Decimal>,
     pub r_short: Decimal,
-    pub r_long: Decimal,
-    pub speed: Decimal,
-    pub trend: Decimal,
+    pub mu: Decimal,
+    pub sigma: Decimal,
+    pub phi: Decimal,
 
     pub prices: Vec<Vec<FixedTimeRangeDeque<Decimal>>>,                         // [[[做市所], [参考所0]], ...]
     pub ks: Vec<Decimal>,
@@ -159,10 +161,12 @@ impl Predictor {
             prev_fitting_time_vec: vec![Decimal::ZERO; params.ref_exchange.len()],
 
             close_price_vec: FixedTimeRangeDeque::new(600_000_000),
+            log_return_vec: Default::default(),
+            r_vec: Default::default(),
             r_short: Default::default(),
-            r_long: Default::default(),
-            speed: Default::default(),
-            trend: Default::default(),
+            mu: Default::default(),
+            sigma: Default::default(),
+            phi: Default::default(),
 
             mid_price: Default::default(),
             ask_price: Default::default(),
@@ -251,7 +255,6 @@ impl Predictor {
                 let len = self.close_price_vec.len();
 
                 // 求最后10秒的均值
-                let mean_10s;
                 if len >= 10 {
                     let mut i = len - 1;
                     let mut sum: Decimal = Decimal::ZERO;
@@ -265,60 +268,23 @@ impl Predictor {
                         i = i - 1;
                     }
 
-                    mean_10s = sum / Decimal::from(10);
+                    let mean_10s = sum / Decimal::from(10);
                     self.r_short = (self.mid_price - mean_10s) / mean_10s;
                     self.r_short.rescale(8);
                 } else {
                     self.r_short = Decimal::ZERO;
-                    mean_10s = self.mid_price;
                 }
 
-                // 求最后300秒的均值，如果秒级k不到300秒，就用5分钟k的收盘价凑合用用
-                let mean_300s;
-                if len >= 300 {
-                    let mut i = len - 1;
-                    let mut sum: Decimal = Decimal::ZERO;
-                    loop {
-                        sum += self.close_price_vec.get(i).unwrap().close;
-
-                        if i == len - 300 {
-                            break
-                        }
-
-                        i = i - 1;
-                    }
-
-                    mean_300s = sum / Decimal::from(300);
-                    self.r_long = (self.mid_price - mean_300s) / mean_300s;
-                    self.r_long.rescale(8);
-                } else if self.record_vec.len() >= 5 && !self.mid_price.is_zero() {
-                    let mut i = self.record_vec.len() - 1;
-                    let mut sum: Decimal = Decimal::ZERO;
-                    loop {
-                        sum += self.record_vec[i].close;
-
-                        if i == self.record_vec.len() - 5 {
-                            break
-                        }
+                // 计算phi
+                if len >= 2 {
+                    let c2 = self.close_price_vec.get(self.close_price_vec.len() - 2).unwrap().close;
+                    let c1 = self.close_price_vec.get(self.close_price_vec.len() - 1).unwrap().close;
 
-                        i = i - 1;
-                    }
-
-                    mean_300s = sum / Decimal::from(5);
-                    self.r_long = (self.mid_price - mean_300s) / mean_300s;
-                    self.r_long.rescale(8);
-                } else {
-                    self.r_long = Decimal::ZERO;
-                    mean_300s = self.mid_price;
+                    let log_return = c1.ln() - c2.ln();
+                    self.log_return_vec.push_back(log_return);
+                    self.mu = Self::calculate_mean(&self.log_return_vec);
+                    self.sigma = Self::calculate_std(&self.log_return_vec);
                 }
-
-                self.speed = if self.r_short > dec!(-0.0001) || self.r_long > dec!(-0.0001) {
-                    Decimal::ONE
-                } else {
-                    self.r_short / self.r_long
-                };
-
-                self.trend = mean_10s / mean_300s;
             }
 
             // 拟合k与b
@@ -431,20 +397,6 @@ impl Predictor {
         self.balance = balance;
     }
 
-    pub fn get_real_rate(price_vec: &FixedTimeRangeDeque<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();
-        let up_rate = (last_fair_price - min_price) / min_price;
-        let down_rate = (max_price - last_fair_price) / max_price;
-
-        if up_rate > down_rate {
-            up_rate
-        } else {
-            -down_rate
-        }
-    }
-
     pub async fn update_fair_price(&mut self, latest_price: &Decimal, index: usize) {
         if self.mid_price.is_zero() {
             return;
@@ -517,8 +469,6 @@ impl Predictor {
         let is_open_long = self.inventory.is_zero()
             && self.fair_price > self.mid_price * dec!(1.0001)
             && self.r_short < -self.params.open
-            // && self.trend < dec!(0.999)
-            && self.speed < dec!(0.1)
         ;
 
         let is_open_short = self.inventory.is_zero()
@@ -622,6 +572,45 @@ impl Predictor {
         info!("========================================行情数据预热完毕==================================")
     }
 
+    // 计算std
+    fn calculate_std(data: &VecDeque<Decimal>) -> Decimal {
+        let n = data.len();
+        if n == 0 {
+            return Decimal::ZERO; // Handle empty vector
+        }
+        if n == 1 {
+            return Decimal::ZERO; // Handle case where there's only one element
+        }
+
+        // Calculate mean
+        let sum: Decimal = data.iter().sum();
+        let mean = sum / Decimal::from(n);
+
+        // Calculate sum of squared differences from the mean
+        let mut squared_differences_sum = Decimal::ZERO;
+        for &value in data {
+            let difference = value - mean;
+            squared_differences_sum += difference * difference;
+        }
+
+        // Calculate sample variance (Bessel's correction)
+        let sample_variance = squared_differences_sum / Decimal::from(n - 1);
+
+        // Calculate sample standard deviation
+        sample_variance.sqrt().unwrap_or(Decimal::ZERO) // Safely handle potential errors
+    }
+
+    fn calculate_mean(data: &VecDeque<Decimal>) -> Decimal {
+        let sum: Decimal = data.iter().sum(); // 计算总和
+        let count = data.len(); // 获取元素个数
+
+        if count == 0 {
+            return Decimal::ZERO; // 处理空向量的情况
+        }
+
+        sum / Decimal::from(count) // 计算平均值
+    }
+
     // 最小二乘法拟合函数，支持VecDeque
     pub async fn linear_least_squares(&self, index: usize) -> Option<(Decimal, Decimal)> {
         let x = &self.prices[index][1];
@@ -697,17 +686,17 @@ impl Predictor {
         let fair_price = self.fair_price;
 
         let spread = Self::DONT_VIEW;
-        let spread_max = self.r_short;
-        let spread_min = self.r_long;
+        let spread_max = self.mu;
+        let spread_min = self.sigma;
         // 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;
 
         let inventory = self.inventory;
 
-        // let sigma_square = Decimal::from(Utc::now().timestamp_millis()) - data_time;
-        let sigma_square = self.speed;
-        let gamma = self.trend;
+        let sigma_square = Decimal::from(Utc::now().timestamp_millis()) - data_time;
+        // let sigma_square = Self::DONT_VIEW;
+        let gamma = Self::DONT_VIEW;
         let kappa = self.balance;
 
         let flow_ratio = Decimal::ZERO;