Rust概率计算库probability使用指南

probability是Rust中一个强大的概率计算和统计库，提供了高效的随机数生成、统计分析和多种概率分布功能。

主要特性

• 多种随机数生成器实现
• 丰富的概率分布类型
• 统计分析和假设检验功能
• 蒙特卡洛模拟支持
• 性能优化，适合科学计算

安装

在Cargo.toml中添加依赖：

[dependencies]
probability = "0.17"
rand = "0.8"  # 推荐同时安装rand作为配套

基本使用方法

1. 随机数生成

use probability::distribution::Gaussian;
use probability::prelude::*;

fn main() {
    let mut source = source::default();  // 默认随机数源
    
    // 生成均匀分布的随机数
    let uniform = Uniform::new(0.0, 1.0);
    println!("Uniform random: {}", uniform.sample(&mut source));
    
    // 生成高斯分布的随机数
    let gaussian = Gaussian::new(0.0, 1.0);
    println!("Gaussian random: {}", gaussian.sample(&mut source));
}

2. 概率分布

use probability::distribution::{Binomial, Exponential, Poisson};

fn distributions_example() {
    // 二项分布
    let binom = Binomial::new(10, 0.5);
    println!("Binomial PMF at 5: {}", binom.pmf(5));
    println!("Binomial CDF at 5: {}", binom.cdf(5));
    
    // 指数分布
    let exp = Exponential::new(1.0);
    println!("Exp PDF at 1.0: {}", exp.pdf(1.0));
    
    // 泊松分布
    let poisson = Poisson::new(3.0);
    println!("Poisson PMF at 2: {}", poisson.pmf(2));
}

3. 统计分析

use probability::statistics::{mean, variance, Statistics};

fn statistics_example() {
    let data = [1.0, 2.0, 3.0, 4.0, 5.0];
    
    // 基本统计量
    println!("Mean: {}", mean(&data));
    println!("Variance: {}", variance(&data));
    
    // 更全面的统计分析
    let stats = data.iter().collect::<Statistics<f64>>();
    println!("Statistics summary: {:?}", stats);
    println!("Median: {}", stats.median());
    println!("Standard deviation: {}", stats.std_dev());
}

4. 蒙特卡洛模拟

use probability::monte_carlo::simulate;

fn monte_carlo_example() {
    // 估算π值
    let pi_estimate = simulate(1_000_000, |rng| {
        let x = rng.next_f64();
        let y = rng.next_f64();
        (x * x + y * y <= 1.0) as u64
    });
    
    println!("Estimated π: {}", 4.0 * pi_estimate);
}

高级功能

自定义分布

use probability::distribution::Distribution;

struct MyCustomDist;

impl Distribution<f64> for MyCustomDist {
    fn sample<S: probability::source::Source>(&self, source: &mut S) -> f64 {
        // 实现自定义采样逻辑
        source.next_f64().ln()
    }
}

fn custom_dist_example() {
    let dist = MyCustomDist;
    let mut source = source::default();
    println!("Custom sample: {}", dist.sample(&mut source));
}

假设检验

use probability::hypothesis::Test;

fn hypothesis_test() {
    let control = [1.0, 2.0, 3.0, 4.0, 5.0];
    let variant = [1.1, 2.2, 3.3, 4.4, 5.5];
    
    let test = Test::new(&control, &variant);
    println!("T-test p-value: {}", test.t_test());
}

性能提示

1. 对于大量重复采样，考虑使用prelude::Independent特性
2. 重用随机数源(Source)对象以提高性能
3. 对于并行计算，确保使用线程安全的随机数源

probability库为Rust提供了全面的概率统计功能，适用于从简单的随机数生成到复杂的统计建模等各种场景。

完整示例demo

下面是一个综合使用probability库的完整示例，展示了随机数生成、概率分布、统计分析和蒙特卡洛模拟的综合应用：

use probability::{
    distribution::{Gaussian, Uniform, Binomial},
    prelude::*,
    statistics::{mean, variance},
    monte_carlo::simulate
};

fn main() {
    // 1. 随机数生成示例
    let mut rng = source::default();
    
    // 生成均匀分布随机数
    let uniform = Uniform::new(0.0, 10.0);
    let uniform_sample = uniform.sample(&mut rng);
    println!("Uniform sample between 0 and 10: {}", uniform_sample);
    
    // 生成正态分布随机数
    let normal = Gaussian::new(0.0, 1.0);
    let normal_sample = normal.sample(&mut rng);
    println!("Normal distributed sample: {}", normal_sample);
    
    // 2. 概率分布示例
    let binom = Binomial::new(20, 0.3);
    println!("Binomial PMF at 5: {}", binom.pmf(5));
    println!("Binomial CDF at 5: {}", binom.cdf(5));
    
    // 3. 统计分析示例
    let data: Vec<f64> = (0..100).map(|_| normal.sample(&mut rng)).collect();
    println!("Data mean: {}", mean(&data));
    println!("Data variance: {}", variance(&data));
    
    // 4. 蒙特卡洛模拟示例 - 计算e的近似值
    let e_estimate = simulate(1_000_000, |rng| {
        let mut sum = 0.0;
        let mut count = 0;
        while sum <= 1.0 {
            sum += rng.next_f64();
            count += 1;
        }
        count as u64
    });
    
    println!("Estimated e: {}", e_estimate as f64);
    
    // 5. 自定义分布示例
    struct LogNormal;
    
    impl Distribution<f64> for LogNormal {
        fn sample<S: Source>(&self, source: &mut S) -> f64 {
            source.next_f64().ln()
        }
    }
    
    let log_normal = LogNormal;
    println!("Log-normal sample: {}", log_normal.sample(&mut rng));
}

这个完整示例展示了：

1. 使用不同分布生成随机数
2. 计算二项分布的概率质量函数和累积分布函数
3. 对生成的数据进行统计分析
4. 使用蒙特卡洛方法估算数学常数e
5. 实现自定义的对数正态分布

使用时请确保已按照前面提到的安装方法添加了依赖项。