Rust statrs

use statrs::statistics::Statistics;

let data = [0.07, 0.14, 0.13, 0.16, 0.12, 0.17, 0.22];

// 均值
let mean = data.mean();

// 中位数
let median = data.median(); 

// 方差和标准差
let variance = data.variance().unwrap();
let std_dev = data.std_dev().unwrap();

// 极值
let min = data.min();
let max = data.max();

use statrs::distribution::{Normal, Continuous};

// 创建正态分布 (均值=0, 标准差=1)
let normal = Normal::new(0.0, 1.0).unwrap();

// 计算PDF/ CDF
let pdf = normal.pdf(1.96);    // x=1.96处的概率密度
let cdf = normal.cdf(1.96);    // P(X ≤ 1.96)

// 生成随机样本
use rand;
let samples = normal.sample(&mut rand::thread_rng(), 100); 

use statrs::statistics::Distribution;
use statrs::statistics::Test;

// t检验（比较两组数据）
let group_a = [0.1, 0.2, 0.15];
let group_b = [0.3, 0.25, 0.4];
let t_test = statrs::statistics::t_test(&group_a, &group_b);

match t_test {
    Ok(result) => println!("p值: {}", result.p_value),
    Err(e) => eprintln!("检验失败: {}", e),
}

// 四分位数
let q1 = data.percentile(25);  // 第一四分位数
let q3 = data.percentile(75);  // 第三四分位数

// 任意分位
let p99 = data.percentile(99); // 99%分位点

use statrs::function::gamma;

// 伽马函数
gamma::gamma(5.0); // 4! = 24

// 贝塔函数
statrs::function::beta::beta(2.0, 5.0);

// 误差函数
statrs::function::erf::erf(1.0); 

// 数据标准化 (Z-score)
let standardized: Vec<_> = data.iter().map(|x| (x - mean) / std_dev).collect();

// 归一化到[0,1]
let min = data.min();
let max = data.max();
let normalized: Vec<_> = data.iter().map(|x| (x - min)/(max - min)).collect();

// 计算对数收益率序列
let log_returns: Vec<_> = prices
    .windows(2)
    .map(|w| (w[1] / w[0]).ln())
    .collect();

// 此时标准差表示收益率波动（更直观）
let ret_std = log_returns.std_dev().unwrap(); // 例如 0.0006（即0.06%）

// 计算20小时滚动波动率
let rolling_volatility: Vec<_> = prices
    .windows(20)
    .map(|w| w.std_dev().unwrap() / w.mean().unwrap())
    .collect();

// 假设1小时数据，年化因子 = sqrt(24*365)
let annualized_vol = std_dev * (24.0 * 365.0).sqrt(); 
// 62.27 → ≈ 6096（即约6%年化波动率）

// 2倍标准差作为止损区间
let stop_loss = current_price - 2.0 * std_dev; // 103639 - 124 = 103515

// 只有突破幅度 > 3倍标准差才确认有效
let breakout_threshold = 3.0 * std_dev; // ≈186美元

// 波动率调整仓位（波动越大仓位越小）
let position_size = (capital * 0.01) / (std_dev / current_price); // 基于波动百分比

// 检查布林带宽度（通常2倍标准差）
let ma = prices.mean().unwrap();
let upper_band = ma + 2.0 * std_dev;
let lower_band = ma - 2.0 * std_dev;
println!("布林带宽度: {:.2}%", (upper_band - lower_band) / ma * 100.0);
// 输出示例: "布林带宽度: 0.24%"

let prices = vec![50000.0, 50100.0, 49000.0, 52000.0]; // 包含一次暴跌
let variance = prices.variance().unwrap(); // 会显著高于平稳数据

// 计算滚动方差（20小时窗口）
let rolling_var: Vec<_> = prices.windows(20).map(|w| w.variance().unwrap()).collect();

// 检测波动率跃升
if rolling_var.last() > Some(2.0 * rolling_var.mean().unwrap()) {
    println!("⚠️ 波动率聚类出现");
}

let upside_var = prices.iter().filter(|&&x| x > mean).map(|x| (x - mean).powi(2)).mean();
let downside_var = prices.iter().filter(|&&x| x < mean).map(|x| (x - mean).powi(2)).mean();

// 上涨波动更强时，放宽止盈
let take_profit = if upside_var > downside_var {
    entry_price + 1.8 * std_dev
} else {
    entry_price + 1.2 * std_dev
};

// 波动率越高，仓位越小（使用方差放大极端波动影响）
let risk_adjusted_size = (capital * 0.02) / variance.sqrt(); // 用方差根而非标准差

// 只有方差 > 历史中位数时才交易
if variance > historical_median_var {
    execute_trend_strategy();
}

// 监测方差与移动平均方差的比率
let var_ratio = variance / rolling_var.mean().unwrap();
if var_ratio > 5.0 {
    trigger_circuit_breaker();
}

let log_var = variance.ln(); 
// 用于机器学习模型输入或波动率预测

let variance = data.variance().unwrap();
let std_dev = data.std_dev().unwrap();
assert!((std_dev.powi(2) - variance).abs() < 1e-10); // 数学上严格相等

let diff = (std_dev.powi(2) - variance).abs();
assert!(diff < 1e-10); // 允许微小浮点误差

let data = [1.0, 1.0, 1.0, 1.0, 1.0e12]; // 包含极端值
// 方差和标准差都会被极端值显著拉高
// 但依然满足 std_dev² ≈ variance

let prices = [103577.0, 103639.0, 103701.0, ...]; // 你的数据
let var = prices.variance().unwrap();   // 3878.0100643772735
let std = prices.std_dev().unwrap();    // 62.273670715457854

// 验证平方关系
println!("{} == {} ? {}", std.powi(2), var, (std.powi(2) - var).abs() < 1e-10);
// 输出: 3878.010064377274 == 3878.0100643772735 ? true

// 错误示例：混用总体方差和样本标准差
let var = population_variance(&data); // 用n
let std = sample_std_dev(&data);      // 用n-1
// 此时 std² ≠ var

let data = [42.0; 10]; // 所有值相同
assert_eq!(data.variance().unwrap(), 0.0);
assert_eq!(data.std_dev().unwrap(), 0.0);
// 需避免除以零等问题

use statrs::distribution::{Normal, Continuous};

// 假设历史数据计算得出
let mean_return = 0.001;  // 平均小时收益率 0.1%
let std_dev = 0.005;      // 标准差 0.5%

let normal = Normal::new(mean_return, std_dev).unwrap();

// 计算1小时内收益率落在±1%的概率
let prob = normal.cdf(0.01) - normal.cdf(-0.01);
println!("1小时收益率在±1%内的概率: {:.2}%", prob * 100.0);

use statrs::distribution::StudentsT;

let degrees_of_freedom = 3.0; // 自由度越低，尾部越厚
let t_dist = StudentsT::new(mean_return, std_dev, degrees_of_freedom).unwrap();

// 计算暴跌5%的概率
let crash_prob = 1.0 - t_dist.cdf(-0.05);
println!("1小时暴跌超过5%的概率: {:.4}%", crash_prob * 100.0);

use statrs::distribution::Poisson;

let lambda = 0.2; // 假设每天发生极端波动的平均次数
let poisson = Poisson::new(lambda).unwrap();

// 计算一天内发生≥2次极端波动的概率
let prob = 1.0 - poisson.cdf(1.0); 
println!("单日≥2次极端波动概率: {:.2}%", prob * 100.0);

use statrs::distribution::Normal;
use rand::distributions::Distribution;

let mut rng = rand::thread_rng();
let normal = Normal::new(mean_return, std_dev).unwrap();

// 模拟未来24小时价格路径
let mut price = 50000.0;
for _ in 0..24 {
    let ret = normal.sample(&mut rng);
    price *= 1.0 + ret;
    println!("模拟价格: {:.2}", price);
}

use statrs::distribution::Normal;

let confidence = 0.95; // 95%置信度
let var = normal.inverse_cdf(1.0 - confidence).abs() * portfolio_value;
println!("1小时95% VaR: ${:.2}", var);

use statrs::distribution::LogNormal;

let strike = 55000.0;
let current = 50000.0;
let vol = 0.8; // 年化波动率80%

let ln_dist = LogNormal::new(current.ln(), vol).unwrap();
let call_prob = 1.0 - ln_dist.cdf(strike.ln());

println!("BTC到期价≥{}的概率: {:.2}%", strike, call_prob * 100.0);