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
117
118
119
120
121
122
123
124
125
126
127
128

use numrs2::array::Array;
use numrs2::array_ops::*;

#[test]
fn test_concatenate_single_axis() {
    // Create test arrays
    let a = Array::from_vec(vec![1, 2, 3]);
    let b = Array::from_vec(vec![4, 5, 6]);

    // Test concatenation along axis 0
    let c = concatenate(&[&a, &b], 0).unwrap();
    assert_eq!(c.shape(), vec![6]);
    assert_eq!(c.to_vec(), vec![1, 2, 3, 4, 5, 6]);

    // Create 2D arrays
    let d = Array::from_vec(vec![1, 2, 3, 4]).reshape(&[2, 2]);
    let e = Array::from_vec(vec![5, 6, 7, 8]).reshape(&[2, 2]);

    // Test concatenation along axis 0 (rows)
    let f = concatenate(&[&d, &e], 0).unwrap();
    assert_eq!(f.shape(), vec![4, 2]);
    assert_eq!(f.to_vec(), vec![1, 2, 3, 4, 5, 6, 7, 8]);

    // Test concatenation along axis 1 (columns)
    let g = concatenate(&[&d, &e], 1).unwrap();
    assert_eq!(g.shape(), vec![2, 4]);
    // The order in the flattened array depends on how ndarray handles memory layout
    // In our implementation, it is row-major order
    let g_vec = g.to_vec();
    assert!(
        g_vec.contains(&1)
            && g_vec.contains(&2)
            && g_vec.contains(&3)
            && g_vec.contains(&4)
            && g_vec.contains(&5)
            && g_vec.contains(&6)
            && g_vec.contains(&7)
            && g_vec.contains(&8)
    );
}

#[test]
fn test_concatenate_multiple_axes() {
    // Create 2D arrays
    let a = Array::from_vec(vec![1, 2, 3, 4]).reshape(&[2, 2]);
    let b = Array::from_vec(vec![5, 6, 7, 8]).reshape(&[2, 2]);

    // Test concatenation along multiple axes
    // For now, we'll focus on single-axis concatenation
    // as multi-axes concatenation requires more complex implementation

    // First concat: a + b along axis 0 -> [1,2,3,4,5,6,7,8] with shape [4,2]
    let _temp = concatenate(&[&a, &b], 0).unwrap();

    // Try the multiple axes version - should be equivalent
    let shortcut = concatenate(&[&a, &b], vec![0]).unwrap();
    assert_eq!(shortcut.shape(), vec![4, 2]);

    // Note: The multiple axes version for different arrays is a complex feature
    // and may require more sophisticated implementation.

    // Verify single-axis concat works as expected
    assert_eq!(shortcut.get(&[0, 0]).unwrap(), 1);
    assert_eq!(shortcut.get(&[0, 1]).unwrap(), 2);
    assert_eq!(shortcut.get(&[2, 0]).unwrap(), 5);
    assert_eq!(shortcut.get(&[2, 1]).unwrap(), 6);
}

#[test]
fn test_stack() {
    // Create test arrays
    let a = Array::from_vec(vec![1, 2, 3]);
    let b = Array::from_vec(vec![4, 5, 6]);

    // Test stacking along a new axis 0
    let c = stack(&[&a, &b], 0).unwrap();
    assert_eq!(c.shape(), vec![2, 3]);
    assert_eq!(c.to_vec(), vec![1, 2, 3, 4, 5, 6]);

    // Test stacking along a new axis 1
    let d = stack(&[&a, &b], 1).unwrap();
    assert_eq!(d.shape(), vec![3, 2]);
    // The exact values depend on the memory layout, but we can check
    // certain elements are in the expected positions
    assert_eq!(d.get(&[0, 0]).unwrap(), 1);
    assert_eq!(d.get(&[0, 1]).unwrap(), 4);
    assert_eq!(d.get(&[1, 0]).unwrap(), 2);
    assert_eq!(d.get(&[1, 1]).unwrap(), 5);
    assert_eq!(d.get(&[2, 0]).unwrap(), 3);
    assert_eq!(d.get(&[2, 1]).unwrap(), 6);
}

#[test]
fn test_array_creation_operations() {
    // Test r_
    let a = Array::from_vec(vec![1, 2, 3]);
    let b = Array::from_vec(vec![4, 5, 6]);
    let c = r_(&[&a, &b]).unwrap();
    assert_eq!(c.shape(), vec![6]);
    assert_eq!(c.to_vec(), vec![1, 2, 3, 4, 5, 6]);

    // Test c_
    let d = c_(&[&a, &b]).unwrap();
    assert_eq!(d.shape(), vec![3, 2]);
    // Check specific elements
    assert_eq!(d.get(&[0, 0]).unwrap(), 1);
    assert_eq!(d.get(&[0, 1]).unwrap(), 4);
    assert_eq!(d.get(&[1, 0]).unwrap(), 2);
    assert_eq!(d.get(&[1, 1]).unwrap(), 5);
    assert_eq!(d.get(&[2, 0]).unwrap(), 3);
    assert_eq!(d.get(&[2, 1]).unwrap(), 6);

    // Test hsplit
    let arr2d = Array::from_vec(vec![1, 2, 3, 4, 5, 6]).reshape(&[2, 3]);
    let splits = hsplit(&arr2d, 3).unwrap();
    assert_eq!(splits.len(), 3);
    assert_eq!(splits[0].shape(), vec![2, 1]);
    assert_eq!(splits[1].shape(), vec![2, 1]);
    assert_eq!(splits[2].shape(), vec![2, 1]);

    // Test vsplit
    let arr2d_t = Array::from_vec(vec![1, 2, 3, 4, 5, 6]).reshape(&[3, 2]);
    let splits_v = vsplit(&arr2d_t, 3).unwrap();
    assert_eq!(splits_v.len(), 3);
    assert_eq!(splits_v[0].shape(), vec![1, 2]);
    assert_eq!(splits_v[1].shape(), vec![1, 2]);
    assert_eq!(splits_v[2].shape(), vec![1, 2]);
}