numrs-core 0.1.15

A high-performance numerical computing library with multi-backend dispatch (SIMD, BLAS/MKL, WebGPU) and zero-cost abstractions
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
147
148

//! Tests for implicit type conversion in Array::from_vec()

use numrs::array::{Array, DType};

#[test]
fn test_from_vec_i32_to_f32() {
    // Create f32 array from i32 data - automatic conversion
    let arr = Array::<f32>::from_vec(vec![3], vec![1i32, 2, 3]);

    assert_eq!(arr.dtype, DType::F32);
    assert_eq!(arr.shape, vec![3]);
    assert_eq!(arr.data, vec![1.0f32, 2.0, 3.0]);
}

#[test]
fn test_from_vec_f32_to_i32() {
    // Create i32 array from f32 data - automatic conversion (truncation)
    let arr = Array::<i32>::from_vec(vec![4], vec![1.5f32, 2.7, 3.2, 4.9]);

    assert_eq!(arr.dtype, DType::I32);
    assert_eq!(arr.shape, vec![4]);
    assert_eq!(arr.data, vec![1, 2, 3, 4]); // Truncated
}

#[test]
fn test_from_vec_i32_to_f64() {
    // Create f64 array from i32 data
    let arr = Array::<f64>::from_vec(vec![2, 2], vec![1i32, 2, 3, 4]);

    assert_eq!(arr.dtype, DType::F64);
    assert_eq!(arr.shape, vec![2, 2]);
    assert_eq!(arr.data, vec![1.0f64, 2.0, 3.0, 4.0]);
}

#[test]
fn test_from_vec_u8_to_f32() {
    // Create f32 array from u8 data (common for image processing)
    let arr = Array::<f32>::from_vec(vec![2, 2], vec![10u8, 20, 30, 40]);

    assert_eq!(arr.dtype, DType::F32);
    assert_eq!(arr.shape, vec![2, 2]);
    assert_eq!(arr.data, vec![10.0f32, 20.0, 30.0, 40.0]);
}

#[test]
fn test_from_vec_f64_to_f32() {
    // Create f32 array from f64 data (precision loss)
    let arr = Array::<f32>::from_vec(vec![3], vec![1.5f64, 2.5, 3.5]);

    assert_eq!(arr.dtype, DType::F32);
    assert_eq!(arr.data, vec![1.5f32, 2.5, 3.5]);
}

#[test]
fn test_from_vec_bool_to_i32() {
    // Create i32 array from bool data
    let arr = Array::<i32>::from_vec(vec![4], vec![true, false, true, true]);

    assert_eq!(arr.dtype, DType::I32);
    assert_eq!(arr.data, vec![1, 0, 1, 1]);
}

#[test]
fn test_from_vec_bool_to_f32() {
    // Create f32 array from bool data
    let arr = Array::<f32>::from_vec(vec![3], vec![true, false, true]);

    assert_eq!(arr.dtype, DType::F32);
    assert_eq!(arr.data, vec![1.0f32, 0.0, 1.0]);
}

#[test]
fn test_from_vec_same_type_f32() {
    // When types match, should be zero-cost (no conversion)
    let arr = Array::<f32>::from_vec(vec![3], vec![1.0f32, 2.0, 3.0]);

    assert_eq!(arr.dtype, DType::F32);
    assert_eq!(arr.data, vec![1.0, 2.0, 3.0]);
}

#[test]
fn test_from_vec_same_type_i32() {
    // When types match, should be zero-cost (no conversion)
    let arr = Array::<i32>::from_vec(vec![3], vec![1i32, 2, 3]);

    assert_eq!(arr.dtype, DType::I32);
    assert_eq!(arr.data, vec![1, 2, 3]);
}

#[test]
#[should_panic(expected = "shape length mismatch")]
fn test_from_vec_shape_mismatch() {
    // Should panic if shape doesn't match data length
    let _arr = Array::<f32>::from_vec(vec![2], vec![1i32, 2, 3]); // 2 != 3
}

#[test]
fn test_from_vec_multidimensional() {
    // Test with multi-dimensional shapes
    let arr = Array::<f32>::from_vec(vec![2, 3], vec![1i32, 2, 3, 4, 5, 6]);

    assert_eq!(arr.dtype, DType::F32);
    assert_eq!(arr.shape, vec![2, 3]);
    assert_eq!(arr.data, vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
}

#[test]
fn test_from_vec_i8_to_f32() {
    // Test with i8 (signed 8-bit)
    let arr = Array::<f32>::from_vec(vec![4], vec![-10i8, 0, 10, 20]);

    assert_eq!(arr.dtype, DType::F32);
    assert_eq!(arr.data, vec![-10.0f32, 0.0, 10.0, 20.0]);
}

#[test]
fn test_from_vec_f32_to_u8() {
    // Create u8 array from f32 (common for image output)
    let arr = Array::<u8>::from_vec(vec![4], vec![10.5f32, 20.7, 30.2, 255.9]);

    assert_eq!(arr.dtype, DType::U8);
    assert_eq!(arr.data, vec![10u8, 20, 30, 255]);
}

#[test]
fn test_new_still_works() {
    // Verify that Array::new() still works normally (no breaking changes)
    let arr = Array::<f32>::new(vec![3], vec![1.0f32, 2.0, 3.0]);

    assert_eq!(arr.dtype, DType::F32);
    assert_eq!(arr.data, vec![1.0, 2.0, 3.0]);
}

#[test]
fn test_from_vec_with_ops() {
    use numrs::ops;

    // Create arrays with different input types using from_vec
    let a = Array::<f32>::from_vec(vec![3], vec![1i32, 2, 3]);
    let b = Array::<f32>::from_vec(vec![3], vec![4u8, 5, 6]);

    // Operations should work normally
    // Result is Array (not DynArray)
    let c = ops::add(&a, &b).expect("add should work");

    assert_eq!(c.dtype, DType::F32);
    assert_eq!(c.data, vec![5.0f32, 7.0, 9.0]);
}