调整sigma值

README.MD

@@ -39,6 +39,10 @@
             ["1715653817313", "2"],         // [时间戳, 波动率^2 1]
             ["1715653817316", "20"],        // [时间戳, 波动率^2 1]
         ],
+        "sigma_mas": [                      // 波动率的平均值                       
+            ["1715653817313", "2"],         // [时间戳, 波动率平均值 1]
+            ["1715653817316", "20"],        // [时间戳, 波动率平均值 1]
+        ],
         "total_size": 3,                    // 总trades条数
         "result_size": 1,                   // 指标数据条数
     },

src/msv.rs

@@ -2,11 +2,10 @@ use std::cmp::{max, min};
 use std::str::FromStr;
 use actix_web::{HttpResponse};
 use chrono::Utc;
-use rust_decimal::Decimal;
+use rust_decimal::{Decimal, MathematicalOps};
 use rust_decimal::prelude::{FromPrimitive, ToPrimitive};
 use rust_decimal_macros::dec;
 use serde_json::{json, Value};
-use tracing::info;
 use crate::db_connector::{get_simple_depths_json, get_trades_json};
 use crate::params_utils::{get_str, parse_str_to_decimal};
 use crate::server::{Response, SimpleDepth, Trade};
@@ -169,7 +168,8 @@ 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 mut t_first = trade.time;
+
+        let mut _t_first = trade.time;
         // 右值
         let mut total_right = Decimal::ZERO;
         loop {
@@ -178,29 +178,47 @@ pub fn generate_msv_by_trades(mut trades: Vec<Trade>, mills_back: Decimal, simpl
 
             // 下标合法性判断
             if sigma_index == 0 || sigma_index + 100 <= index {
-                t_first = flag_trade.time;
+                _t_first = flag_trade.time;
                 break;
             }
 
             // 计算差值
             let diff = Decimal::ONE - flag_trade.price / next_trade.price;
-            total_right += diff.abs();
+            total_right += diff * diff;
 
             sigma_index = sigma_index - 1;
         }
-        let mut sigma = if sigma_index + 100 > index {
-            Decimal::ZERO
+        let sigma_square = if _t_first == t_last {
+            let time_diff = Decimal::ONE;
+            (Decimal::ONE / time_diff) * total_right
         } else {
-            if t_first == t_last {
-                let time_diff = dec!(0.001);
-                (Decimal::ONE / time_diff) * total_right
-            } else {
-                let time_diff = (t_last - t_first) / Decimal::ONE_THOUSAND;
-                (Decimal::ONE / time_diff) * total_right
-            }
+            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);
-        sigma_data.push(vec![trade.time, sigma]);
+        // 计算过去至多100个sigma值的平均值
+        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_data.push(vec![trade.time, sigma, sigma_ma]);
+        } else {
+            sigma_data.push(vec![trade.time, sigma, sigma]);
+        }
 
         // ==================== 波动逻辑计算 ====================
         let last_price = trade.price;
@@ -253,6 +271,7 @@ pub fn generate_msv_by_trades(mut trades: Vec<Trade>, mills_back: Decimal, simpl
     let mut final_msv_data: Vec<Vec<Decimal>> = vec![];
     let mut final_epr_data: Vec<Vec<Decimal>> = vec![];
     let mut final_sigma_data: Vec<Vec<Decimal>> = vec![];
+    let mut final_sigma_ma_data: Vec<Vec<Decimal>> = vec![];
 
     let mut depth_index = 0;
     let mut final_volume_data: Vec<Vec<Decimal>> = vec![];
@@ -265,6 +284,7 @@ pub fn generate_msv_by_trades(mut trades: Vec<Trade>, mills_back: Decimal, simpl
         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;
 
         // ====================================== 数据生产 ===============================================
         // 获取时间范围内的波动率数据
@@ -284,16 +304,20 @@ pub fn generate_msv_by_trades(mut trades: Vec<Trade>, mills_back: Decimal, simpl
             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];
             // 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;
             }
             // // 波动率sigma
             // if max_sigma_data.abs() < sigma_d {
+            //     max_sigma_data = sigma_d;
             // }
+
             // 下标步近
             msv_index = msv_index + 1;
         }
@@ -353,8 +377,10 @@ pub fn generate_msv_by_trades(mut trades: Vec<Trade>, mills_back: Decimal, simpl
 
             if final_sigma_data.len() > 0 {
                 final_sigma_data.push(final_sigma_data[final_sigma_data.len() - 1].clone());
+                final_sigma_ma_data.push(final_sigma_ma_data[final_sigma_ma_data.len() - 1].clone());
             } else {
                 final_sigma_data.push(vec![index_timestamp, Decimal::ZERO]);
+                final_sigma_ma_data.push(vec![index_timestamp, Decimal::ZERO]);
             }
 
         // 说明在这个时间范围内是有数据存在的，将各类副图放置完全
@@ -367,6 +393,7 @@ pub fn generate_msv_by_trades(mut trades: Vec<Trade>, mills_back: Decimal, simpl
             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]);
         }
 
         // ====================================== 时间步进处理 ======================================
@@ -386,6 +413,7 @@ pub fn generate_msv_by_trades(mut trades: Vec<Trade>, mills_back: Decimal, simpl
         "liqs": final_volume_data,
         "eprs": final_epr_data,
         "sigmas": final_sigma_data,
+        "sigma_mas": final_sigma_ma_data,
         "total_size": total_size,
         "result_size": result_size,
     })