numrs2 0.3.1

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
117
118
119

#![allow(deprecated)]

use numrs2::prelude::*;

fn main() {
    println!("NumRS Array Comparison Operations Example");
    println!("========================================\n");

    // Create some arrays for demonstration
    let a = Array::from_vec(vec![1.0, 2.0, 3.0, 4.0]);
    let b = Array::from_vec(vec![1.0000001, 2.0000002, 3.0000003, 5.0]);
    let c = Array::from_vec(vec![1.01, 2.02, 3.03, 4.04]);

    // 1. allclose - Testing approximate equality with default tolerances
    println!("1. Testing array approximate equality with allclose:");
    println!("A = {:?}", a.to_vec());
    println!("B = {:?}", b.to_vec());
    println!("C = {:?}", c.to_vec());
    println!(
        "allclose(A, B) with default tolerances (rtol=1e-7, atol=0): {}",
        allclose(&a, &b)
    );
    println!(
        "allclose(A, C) with default tolerances: {}",
        allclose(&a, &c)
    );

    // 2. allclose with custom tolerances
    println!("\n2. Testing with custom tolerances:");
    println!(
        "allclose(A, C) with rtol=0.01, atol=0: {}",
        allclose_with_tol(&a, &c, 0.01, 0.0)
    );

    // 3. isclose - Element-wise approximate equality
    println!("\n3. Testing element-wise approximate equality with isclose_array:");
    let result = isclose_array(&a, &c, 0.01, 0.0).unwrap();
    println!("isclose_array(A, C) with rtol=0.01, atol=0:");
    println!("{:?}", result.to_vec());

    // 4. array_equal - Exact equality test
    println!("\n4. Testing exact equality with array_equal:");
    let exact_a = Array::from_vec(vec![1, 2, 3, 4]);
    let exact_b = Array::from_vec(vec![1, 2, 3, 4]);
    let exact_c = Array::from_vec(vec![1, 2, 3, 5]);
    println!(
        "array_equal for identical arrays: {}",
        array_equal(&exact_a, &exact_b, None)
    );
    println!(
        "array_equal for different arrays: {}",
        array_equal(&exact_a, &exact_c, None)
    );

    // 5. Comparison operations (greater, less, etc.)
    println!("\n5. Comparison operations:");
    println!("A = {:?}", a.to_vec());
    println!("B = {:?}", b.to_vec());

    // greater
    let result = greater(&a, &b).unwrap();
    println!("greater(A, B): {:?}", result.to_vec());

    // less
    let result = less(&a, &b).unwrap();
    println!("less(A, B): {:?}", result.to_vec());

    // equal
    let result = equal(&a, &b).unwrap();
    println!("equal(A, B): {:?}", result.to_vec());

    // not_equal
    let result = not_equal(&a, &b).unwrap();
    println!("not_equal(A, B): {:?}", result.to_vec());

    // 6. Broadcasting with comparisons
    println!("\n6. Broadcasting with comparisons:");
    let row = Array::from_vec(vec![1.0, 2.0, 3.0]).reshape(&[1, 3]);
    let col = Array::from_vec(vec![1.0, 2.0, 3.0]).reshape(&[3, 1]);

    println!("row = {:?} with shape {:?}", row.to_vec(), row.shape());
    println!("col = {:?} with shape {:?}", col.to_vec(), col.shape());

    let result = greater_equal(&col, &row).unwrap();
    println!("greater_equal(col, row) (with broadcasting):");
    println!("Shape: {:?}", result.shape());
    println!("Values: {:?}", result.to_vec());

    // 7. all and any functions
    println!("\n7. all and any functions:");
    let all_true = Array::from_vec(vec![true, true, true]);
    let some_true = Array::from_vec(vec![false, true, false]);
    let none_true = Array::from_vec(vec![false, false, false]);

    println!("all([true, true, true]): {}", all(&all_true));
    println!("all([false, true, false]): {}", all(&some_true));
    println!("any([false, true, false]): {}", any(&some_true));
    println!("any([false, false, false]): {}", any(&none_true));

    // 8. Using boolean arrays for filtering
    println!("\n8. Using comparison results for filtering:");
    let data = Array::from_vec(vec![1.0, 5.0, 3.0, 8.0, 2.0, 7.0]);
    let threshold = Array::from_vec(vec![4.0]); // Using array for broadcasting

    println!("data = {:?}", data.to_vec());
    println!("Creating mask where data > 4.0");

    let mask = greater(&data, &threshold).unwrap();
    println!("mask = {:?}", mask.to_vec());

    // In NumPy, we'd do data[mask], but in NumRS we need to do this differently
    // We'll show the indices where the condition is true
    println!("Indices where data > 4.0:");
    for (i, &is_greater) in mask.to_vec().iter().enumerate() {
        if is_greater {
            println!("  Index {}: {}", i, data.get(&[i]).unwrap());
        }
    }
}