peroxide 0.41.2

Rust comprehensive scientific computation library contains linear algebra, numerical analysis, statistics and machine learning tools with familiar syntax
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

#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;

#[test]
fn series_map_test() {
    // Int
    let a: Vec<i32> = vec![1, 2, 3, 4, 5];
    let b: Vec<i32> = a.iter().map(|x| 2 * *x + 1).collect();
    let s_a = Series::new(a);
    let s_b = Series::new(b);
    assert_eq!(s_b, s_a.map(|t: i32| 2 * t + 1));

    // F64
    let a: Vec<f64> = vec![1.0, 2.0, 3.0, 4.0, 5.0];
    let b: Vec<f64> = a.iter().map(|x| 2f64 * *x + 1f64).collect();
    let s_a = Series::new(a);
    let s_b = Series::new(b);
    assert_eq!(s_b, s_a.map(|t: f64| 2f64 * t + 1f64));
}

#[test]
fn series_fold_test() {
    // Int
    let a: Vec<i32> = vec![1, 2, 3, 4, 5];
    let b = a.iter().fold(0, |x, y| x + *y);
    let s_a = Series::new(a);
    assert_eq!(b, s_a.fold(0i32, |x, y| x + y));

    // F64
    let a: Vec<f64> = c!(1, 2, 3, 4, 5);
    let b = a.iter().fold(0f64, |x, y| x + *y);
    let s_a = Series::new(a);
    assert_eq!(b, s_a.fold(0f64, |x, y| x + y));
}

#[test]
fn series_filter_test() {
    // Int
    let a: Vec<i32> = vec![1, 2, 3, 4, 5];
    let b: Vec<i32> = a.clone().into_iter().filter(|x| *x % 2 == 0).collect();
    let s_a = Series::new(a);
    let s_b = Series::new(b);
    assert_eq!(s_b, s_a.filter(|x: &i32| *x % 2 == 0));

    // F64
    let a: Vec<f64> = c!(1, 2, 3, 4, 5);
    let b: Vec<f64> = a
        .clone()
        .into_iter()
        .filter(|x| *x % 2f64 == 0f64)
        .collect();
    let s_a = Series::new(a);
    let s_b = Series::new(b);
    assert_eq!(s_b, s_a.filter(|x: &f64| *x % 2f64 == 0f64));
}

#[test]
fn series_zip_with_test() {
    // Int
    let a: Vec<i32> = vec![1, 2, 3, 4, 5];
    let b: Vec<i32> = vec![5, 4, 3, 2, 1];
    let c: Vec<i32> = a.iter().zip(b.iter()).map(|(x, y)| x + y).collect();
    let s_a = Series::new(a);
    let s_b = Series::new(b);
    let s_c = Series::new(c);
    assert_eq!(s_c, s_a.zip_with(|x: i32, y: i32| x + y, &s_b));
}