rhai-sci 0.4.0

Scientific computing in the Rhai scripting language
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

use rhai::{packages::Package, Engine};
use rhai_sci::SciPackage;

fn engine() -> Engine {
    let mut engine = Engine::new();
    engine.register_global_module(SciPackage::new().as_shared_module());
    engine
}

#[test]
fn statistics_and_signal_operations_accept_every_vector_orientation() {
    let engine = engine();
    for values in ["[1, 2, 3]", "[1, 2.0, 3]"] {
        for vector in [
            values.to_string(),
            format!("row({values})"),
            format!("col({values})"),
        ] {
            let script = format!(
                r#"
                let samples = {vector};
                let before = samples;
                assert_eq(mean(samples), 2.0);
                assert_eq(std(samples), 1.0);
                assert_eq(median(samples), 2.0);
                assert_approx_eq(min(samples).to_float(), 1.0);
                assert_approx_eq(max(samples).to_float(), 3.0);
                assert_eq(argmax(samples), 2);
                assert_eq(argmin(samples), 0);
                assert_approx_eq(movmean(samples, 3), [1.5, 2.0, 2.5]);
                assert_approx_eq(cumsum(samples), [1.0, 3.0, 6.0]);
                assert_approx_eq(diff(samples), [1.0, 1.0]);
                assert_eq(samples, before);
            "#
            );
            engine
                .run(&script)
                .unwrap_or_else(|error| panic!("{vector}: {error}"));
        }
    }
}

#[test]
fn paired_sample_operations_compare_vector_lengths_after_normalizing() {
    engine()
        .run(
            r#"
        let x = row([0, 1, 2]);
        let y = col([1, 3.0, 5]);
        assert_eq(trapz(x, y), 6.0);
        assert_approx_eq(cumtrapz(x, y), [0.0, 2.0, 6.0]);
        assert_eq(interp1(x, y, 0.5), 2.0);
    "#,
        )
        .unwrap();
}

#[test]
fn malformed_vectors_return_script_errors() {
    let engine = engine();
    for data in [
        "[[1], [2, 3]]",
        "[[1, 2], [3, 4]]",
        "[1, [2]]",
        "[[1, \"x\"]]",
        "[]",
        "[[]]",
    ] {
        for function in ["mean", "median", "std", "max", "argmax"] {
            let script = format!("{function}({data})");
            assert!(engine.eval::<rhai::Dynamic>(&script).is_err(), "{script}");
        }
    }
    for script in [
        "trapz(row([1, 2]), col([1, 2, 3]))",
        "cumtrapz(row([1, 2]), row([1, 2, 3]))",
        "interp1(row([1, 2]), row([1, 2, 3]), 1.5)",
    ] {
        assert!(engine.eval::<rhai::Dynamic>(script).is_err(), "{script}");
    }
}

#[test]
fn integer_statistics_preserve_values_above_float_precision() {
    engine()
        .run(
            r#"
        let n = 9007199254740993;
        assert_eq(max(col([n, n - 1])), n);
        assert_eq(argmax(col([n - 1, n])), 1);
        assert_eq(sum(row([n, 0])), n);
    "#,
        )
        .unwrap();
}

#[test]
fn empty_list_identities_remain_available() {
    engine()
        .run(
            r#"
        assert_eq(sum([]), 0);
        assert_eq(prod([]), 1);
        assert_eq(diff([]), []);
        assert_eq(unique([]), []);
        assert_eq(size([]), [0]);
        assert_eq(size([[]]), [1, 0]);
    "#,
        )
        .unwrap();
}