r2rs-stats 0.1.1

Statistics programming for Rust based on R's stats package
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

// "Whatever you do, work at it with all your heart, as working for the Lord,
// not for human masters, since you know that you will receive an inheritance
// from the Lord as a reward. It is the Lord Christ you are serving."
// (Col 3:23-24)

use std::str::FromStr;

use strafe_testing::{
    r::{RGenerator, RString, RTester},
    r_assert_relative_equal_result,
};

use crate::distance::{
    binary::binary, canberra::canberra, euclidean::euclidean, manhattan::manhattan,
    maximum::maximum, minkowski::minkowski, row_distances,
};

pub fn binary_test_inner(seed: u16, row_size: f64, column_size: f64) {
    let x = RTester::new()
        .set_seed(seed)
        .set_script(&RString::from_string(format!(
            "ret = round(matrix(runif({0}*{1}), ncol={1}, nrow={0}), digits=3);",
            RString::from_f64(row_size),
            RString::from_f64(column_size),
        )))
        .set_display(&RString::from_str("ret").unwrap())
        .run()
        .expect("R running error")
        .as_f64_matrix()
        .expect("R running error");
    let rust_ret = row_distances(&x, &binary);
    let r_ret = RTester::new()
        .set_script(&RString::from_string(format!(
            "ret = dist({}, 'binary', upper=T, diag=T);",
            RString::from_f64_matrix(&x),
        )))
        .set_display(&RString::from_str("ret").unwrap())
        .run()
        .expect("R running error")
        .as_f64_matrix()
        .expect("R running error");
    for (&rust, &r) in rust_ret.iter().zip(r_ret.iter()) {
        r_assert_relative_equal_result!(Ok(r), &rust);
    }
}

pub fn canberra_test_inner(seed: u16, row_size: f64, column_size: f64) {
    let x = RGenerator::new()
        .set_seed(seed)
        .generate_uniform_matrix(row_size, column_size, (0, 1));
    let rust_ret = row_distances(&x, &canberra);
    let r_ret = RTester::new()
        .set_script(&RString::from_string(format!(
            "ret = dist({}, 'canberra', upper=T, diag=T);",
            RString::from_f64_matrix(&x),
        )))
        .set_display(&RString::from_str("ret").unwrap())
        .run()
        .expect("R running error")
        .as_f64_matrix()
        .expect("R running error");
    for (rust, r) in rust_ret.iter().zip(r_ret.iter()) {
        r_assert_relative_equal_result!(Ok(*r), rust);
    }
}

pub fn euclidean_test_inner(seed: u16, row_size: f64, column_size: f64) {
    let x = RGenerator::new()
        .set_seed(seed)
        .generate_uniform_matrix(row_size, column_size, (0, 1));
    let rust_ret = row_distances(&x, &euclidean);
    let r_ret = RTester::new()
        .set_script(&RString::from_string(format!(
            "ret = dist({}, 'euclidean', upper=T, diag=T);",
            RString::from_f64_matrix(&x),
        )))
        .set_display(&RString::from_str("ret").unwrap())
        .run()
        .expect("R running error")
        .as_f64_matrix()
        .expect("R running error");
    for (rust, r) in rust_ret.iter().zip(r_ret.iter()) {
        r_assert_relative_equal_result!(Ok(*r), rust);
    }
}

pub fn manhattan_test_inner(seed: u16, row_size: f64, column_size: f64) {
    let x = RGenerator::new()
        .set_seed(seed)
        .generate_uniform_matrix(row_size, column_size, (0, 1));
    let rust_ret = row_distances(&x, &manhattan);
    let r_ret = RTester::new()
        .set_script(&RString::from_string(format!(
            "ret = dist({}, 'manhattan', upper=T, diag=T);",
            RString::from_f64_matrix(&x),
        )))
        .set_display(&RString::from_str("ret").unwrap())
        .run()
        .expect("R running error")
        .as_f64_matrix()
        .expect("R running error");
    for (rust, r) in rust_ret.iter().zip(r_ret.iter()) {
        r_assert_relative_equal_result!(Ok(*r), rust);
    }
}

pub fn maximum_test_inner(seed: u16, row_size: f64, column_size: f64) {
    let x = RGenerator::new()
        .set_seed(seed)
        .generate_uniform_matrix(row_size, column_size, (0, 1));
    let rust_ret = row_distances(&x, &maximum);
    let r_ret = RTester::new()
        .set_script(&RString::from_string(format!(
            "ret = dist({}, 'maximum', upper=T, diag=T);",
            RString::from_f64_matrix(&x),
        )))
        .set_display(&RString::from_str("ret").unwrap())
        .run()
        .expect("R running error")
        .as_f64_matrix()
        .expect("R running error");
    for (rust, r) in rust_ret.iter().zip(r_ret.iter()) {
        r_assert_relative_equal_result!(Ok(*r), rust);
    }
}

pub fn minkowski_test_inner(seed: u16, p: f64, row_size: f64, column_size: f64) {
    let x = RGenerator::new()
        .set_seed(seed)
        .generate_uniform_matrix(row_size, column_size, (0, 1));
    let rust_ret = row_distances(&x, &|x1, x2| minkowski(x1, x2, p));
    let r_ret = RTester::new()
        .set_script(&RString::from_string(format!(
            "ret = dist({}, p={}, 'minkowski', upper=T, diag=T);",
            RString::from_f64_matrix(&x),
            RString::from_f64(p),
        )))
        .set_display(&RString::from_str("ret").unwrap())
        .run()
        .expect("R running error")
        .as_f64_matrix()
        .expect("R running error");
    for (rust, r) in rust_ret.iter().zip(r_ret.iter()) {
        r_assert_relative_equal_result!(Ok(*r), rust);
    }
}