公平价格（仿真）以及它的ema

src/msv.rs

@@ -2,7 +2,7 @@ use std::cmp::{max, min};
 use std::str::FromStr;
 use actix_web::{HttpResponse};
 use chrono::Utc;
-use rust_decimal::{Decimal, MathematicalOps};
+use rust_decimal::{Decimal};
 use rust_decimal::prelude::{FromPrimitive, ToPrimitive};
 use rust_decimal_macros::dec;
 use serde_json::{json, Value};
@@ -108,8 +108,9 @@ pub fn generate_msv_by_trades(mut trades: Vec<Trade>, mills_back: Decimal, simpl
     let mut msv_data: Vec<Vec<Decimal>> = vec![];
     // 预期利润幅度(except_profit_rate)
     let mut epr_data: Vec<Vec<Decimal>> = vec![];
-    // 波动率sigma
-    let mut sigma_data: Vec<Vec<Decimal>> = vec![];
+    // 公平价格相关
+    let mut fair_data: Vec<Vec<Decimal>> = vec![];
+    let mut fair_price_simulation_ema = Decimal::ZERO;
 
     const GAMMA: Decimal = dec!(0.5);
 
@@ -122,8 +123,8 @@ pub fn generate_msv_by_trades(mut trades: Vec<Trade>, mills_back: Decimal, simpl
 
         // 该元素向前遍历range毫秒
         let mut range_index = index;
-        // 该区间的预定价格
-        let mut ref_price = trade.price;
+        // 该区间的公平价格
+        let mut fair_price = trade.price;
         let mut dissociation = Decimal::ZERO;
         loop {
             // 下标合法性判断
@@ -138,13 +139,13 @@ pub fn generate_msv_by_trades(mut trades: Vec<Trade>, mills_back: Decimal, simpl
                 break;
             }
 
-            ref_price = ref_price * GAMMA + flag_trade.price * (Decimal::ONE - GAMMA);
+            fair_price = fair_price * GAMMA + flag_trade.price * (Decimal::ONE - GAMMA);
             dissociation = dissociation + flag_trade.size.abs();
 
             range_index -= 1;
         }
 
-        // 获取到range毫秒以后的预定价格，计算回去的幅度
+        // 获取到range毫秒以后的公平价格，计算回去的幅度
         let mut future_ref_price_sum = Decimal::ZERO;
         let mut future_ref_count = Decimal::ZERO;
         let mut future_range_index = index + 1;
@@ -174,7 +175,7 @@ pub fn generate_msv_by_trades(mut trades: Vec<Trade>, mills_back: Decimal, simpl
 
         // 计算过去至多100条数据的sigma值 sigma^2 = (1 / (tn-t0))*sum((S(tk) - S(tk-1)) ^ 2)
         let mut sigma_index = index - 1;
-        let t_last = trade.time;
+        // let t_last = trade.time;
 
         let mut _t_first = trade.time;
         // 右值
@@ -195,41 +196,17 @@ pub fn generate_msv_by_trades(mut trades: Vec<Trade>, mills_back: Decimal, simpl
 
             sigma_index = sigma_index - 1;
         }
-        let sigma_square = if _t_first == t_last {
-            let time_diff = Decimal::ONE;
-            (Decimal::ONE / time_diff) * total_right
-        } else {
-            let time_diff = (t_last - _t_first) / Decimal::ONE_THOUSAND;
-            (Decimal::ONE / time_diff) * total_right
-        };
-        let mut sigma = sigma_square.sqrt().unwrap();
-        sigma.rescale(6);
-        // 计算过去至多100个sigma值的平均值
-        let sigma_ma = if sigma_data.len() > 0 {
-            let mut sigma_ma_index = sigma_data.len();
-            let mut sigma_total = Decimal::ZERO;
-            let mut sigma_count = Decimal::ZERO;
-            loop {
-                if sigma_ma_index == 0 || sigma_ma_index + 99 < sigma_data.len() {
-                    break
-                }
-                // 步进
-                sigma_ma_index -= 1;
-                // 计算
-                sigma_total += sigma_data[sigma_ma_index][1];
-                sigma_count += Decimal::ONE;
-            }
-            let mut sigma_ma = sigma_total / sigma_count;
-            sigma_ma.rescale(6);
 
-            sigma_ma
+        // 计算公平价格仿真值的ema
+        fair_price_simulation_ema = if fair_price_simulation_ema.is_zero() {
+            fair_price
         } else {
-            sigma
+            fair_price_simulation_ema * dec!(0.999967) + fair_price * dec!(0.000033)
         };
 
         // ==================== 波动逻辑计算 ====================
         let last_price = trade.price;
-        let mut rate = Decimal::ONE_HUNDRED * (last_price - ref_price) / ref_price;
+        let mut rate = Decimal::ONE_HUNDRED * (last_price - fair_price) / fair_price;
         rate.rescale(2);
         // 去除小数位之后，可以忽略一些太小的波动，减少图表生成压力
         if rate.eq(&Decimal::ZERO) {
@@ -264,18 +241,18 @@ pub fn generate_msv_by_trades(mut trades: Vec<Trade>, mills_back: Decimal, simpl
                     epr_data.remove(epr_data.len() - 1);
                     epr_data.push(vec![trade.time, epr]);
 
-                    sigma_data.remove(sigma_data.len() - 1);
-                    sigma_data.push(vec![trade.time, sigma, sigma_ma]);
+                    fair_data.remove(fair_data.len() - 1);
+                    fair_data.push(vec![trade.time, fair_price, fair_price_simulation_ema]);
                 }
             } else {
                 msv_data.push(vec![trade.time, rate, dissociation]);
                 epr_data.push(vec![trade.time, epr]);
-                sigma_data.push(vec![trade.time, sigma, sigma_ma]);
+                fair_data.push(vec![trade.time, fair_price, fair_price_simulation_ema]);
             }
         } else {
             msv_data.push(vec![trade.time, rate, dissociation]);
             epr_data.push(vec![trade.time, epr]);
-            sigma_data.push(vec![trade.time, sigma, sigma_ma]);
+            fair_data.push(vec![trade.time, fair_price, fair_price_simulation_ema]);
         }
     }
 
@@ -296,8 +273,8 @@ pub fn generate_msv_by_trades(mut trades: Vec<Trade>, mills_back: Decimal, simpl
         let mut max_msv_data = Decimal::ZERO;
         let mut max_msv_qty_data = Decimal::ZERO;
         let mut max_epr_data = Decimal::ZERO;
-        let mut max_sigma_data = Decimal::ZERO;
-        let mut max_sigma_ma_data = Decimal::ZERO;
+        let mut max_fair_d = Decimal::ZERO;
+        let mut max_fair_ema_d = Decimal::ZERO;
 
         // ====================================== 数据生产 ===============================================
         // 获取时间范围内的波动率数据
@@ -316,15 +293,15 @@ pub fn generate_msv_by_trades(mut trades: Vec<Trade>, mills_back: Decimal, simpl
             let msv_d = msv_data[msv_index][1];
             let msv_qty_data = msv_data[msv_index][2];
             let epr_d = epr_data[msv_index][1];
-            let sigma_d = sigma_data[msv_index][1];
-            let sigma_ma_d = sigma_data[msv_index][2];
+            let fair_d = fair_data[msv_index][1];
+            let fair_ema_d = fair_data[msv_index][2];
             // msv波动数据
             if max_msv_data.abs() < msv_d.abs() {
                 max_msv_data = msv_d;
                 max_msv_qty_data = msv_qty_data;
                 max_epr_data = epr_d;
-                max_sigma_data = sigma_d;
-                max_sigma_ma_data = sigma_ma_d;
+                max_fair_d = fair_d;
+                max_fair_ema_d = fair_ema_d;
             }
             // // 波动率sigma
             // if max_sigma_data.abs() < sigma_d {
@@ -405,8 +382,8 @@ pub fn generate_msv_by_trades(mut trades: Vec<Trade>, mills_back: Decimal, simpl
             final_qty.rescale(2);
             final_volume_data.push(vec![index_timestamp, final_qty]);
 
-            final_sigma_data.push(vec![index_timestamp, max_sigma_data]);
-            final_sigma_ma_data.push(vec![index_timestamp, max_sigma_ma_data]);
+            final_sigma_data.push(vec![index_timestamp, max_fair_d]);
+            final_sigma_ma_data.push(vec![index_timestamp, max_fair_ema_d]);
         }
 
         // ====================================== 时间步进处理 ======================================