numrs2 0.3.2

A Rust implementation inspired by NumPy for numerical computing (NumRS2)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

#[cfg(test)]
mod tests {
    use numrs2::array::Array;
    use numrs2::random::{self, set_seed};

    /// This is a helper test to generate the reference values for all the distributions
    /// Run this test with:
    /// cargo test --test test_random_values_collector -- --nocapture
    #[test]
    fn collect_random_reference_values() {
        // Set the seed to 42 for reproducibility
        set_seed(42);

        // Normal distribution
        println!("// Normal distribution reference values");
        let normal_samples = random::normal(0.0, 1.0, &[5]).unwrap();
        println!("let expected_values = vec![");
        for val in normal_samples.to_vec() {
            println!("    {:.16},", val);
        }
        println!("];\n");

        // Beta distribution
        println!("// Beta distribution reference values");
        let beta_samples = random::beta(2.0, 5.0, &[5]).unwrap();
        println!("let expected_values = vec![");
        for val in beta_samples.to_vec() {
            println!("    {:.16},", val);
        }
        println!("];\n");

        // Uniform distribution
        println!("// Uniform distribution reference values");
        let uniform_samples = random::uniform(0.0, 1.0, &[5]).unwrap();
        println!("let expected_values = vec![");
        for val in uniform_samples.to_vec() {
            println!("    {:.16},", val);
        }
        println!("];\n");

        // Gamma distribution
        println!("// Gamma distribution reference values");
        let gamma_samples = random::gamma(2.0, 3.0, &[5]).unwrap();
        println!("let expected_values = vec![");
        for val in gamma_samples.to_vec() {
            println!("    {:.16},", val);
        }
        println!("];\n");

        // Integers distribution
        println!("// Integers distribution reference values");
        let int_samples = random::integers(1, 100, &[10]).unwrap();
        println!("let expected_values = vec![");
        for val in int_samples.to_vec() {
            println!("    {},", val);
        }
        println!("];\n");

        // Binomial distribution
        println!("// Binomial distribution reference values");
        let binomial_samples = random::binomial::<u64>(20, 0.3, &[5]).unwrap();
        println!("let expected_values = vec![");
        for val in binomial_samples.to_vec() {
            println!("    {},", val);
        }
        println!("];\n");

        // Poisson distribution
        println!("// Poisson distribution reference values");
        let poisson_samples = random::poisson::<u64>(5.0, &[5]).unwrap();
        println!("let expected_values = vec![");
        for val in poisson_samples.to_vec() {
            println!("    {},", val);
        }
        println!("];\n");

        // Multivariate normal distribution
        println!("// Multivariate normal distribution reference values");
        let mean = vec![1.0, 2.0];
        let cov_data = vec![1.0, 0.5, 0.5, 2.0];
        let cov = Array::from_vec(cov_data).reshape(&[2, 2]);
        let mvn_samples = random::multivariate_normal(&mean, &cov, Some(&[2])).unwrap();
        println!("let expected_values = vec![");
        for val in mvn_samples.to_vec() {
            println!("    {:.16},", val);
        }
        println!("];\n");

        // Exponential distribution
        println!("// Exponential distribution reference values");
        let exp_samples = random::exponential(2.0, &[5]).unwrap();
        println!("let expected_values = vec![");
        for val in exp_samples.to_vec() {
            println!("    {:.16},", val);
        }
        println!("];\n");

        // Lognormal distribution
        println!("// Lognormal distribution reference values");
        let lognormal_samples = random::lognormal(0.0, 1.0, &[5]).unwrap();
        println!("let expected_values = vec![");
        for val in lognormal_samples.to_vec() {
            println!("    {:.16},", val);
        }
        println!("];\n");

        // Weibull distribution
        println!("// Weibull distribution reference values");
        let weibull_samples = random::weibull(2.0, 3.0, &[5]).unwrap();
        println!("let expected_values = vec![");
        for val in weibull_samples.to_vec() {
            println!("    {:.16},", val);
        }
        println!("];");
    }
}