num_vector 0.1.0

Enabling basic vector arithmetic operations
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

#[cfg(test)]
use crate::NumVector;

#[test]
fn test_new_and_empty() {
    let vec1 = NumVector::new(vec![1, 2, 3]);
    assert_eq!(vec1.get(), &vec![1, 2, 3]);

    let empty_vec: NumVector<i32> = NumVector::empty();
    assert_eq!(empty_vec.get(), &Vec::<i32>::new());
}

#[test]
fn test_addition() {
    let vec1 = NumVector::new(vec![1, 2, 3]);
    let vec2 = NumVector::new(vec![4, 5, 6]);
    let result = &vec1 + &vec2;
    assert_eq!(result.get(), &vec![5, 7, 9]);
}

#[test]
fn test_subtraction() {
    let vec1 = NumVector::new(vec![4, 5, 6]);
    let vec2 = NumVector::new(vec![1, 2, 3]);
    let result = &vec1 - &vec2;
    assert_eq!(result.get(), &vec![3, 3, 3]);
}

#[test]
fn test_scalar_multiplication() {
    let vec = NumVector::new(vec![1, 2, 3]);
    let result = &vec * 2;
    assert_eq!(result.get(), &vec![2, 4, 6]);
}

#[test]
fn test_scalar_division() {
    let vec = NumVector::new(vec![2, 4, 6]);
    let result = &vec / 2;
    assert_eq!(result.get(), &vec![1, 2, 3]);
}

#[test]
#[should_panic(expected = "assertion failed: rhs != 0")]
fn test_scalar_division_by_zero() {
    let mut vec = NumVector::new(vec![1, 2, 3]);
    vec /= 0; // This should panic
}

#[test]
fn test_add_assign() {
    let mut vec1 = NumVector::new(vec![1, 2, 3]);
    let vec2 = NumVector::new(vec![4, 5, 6]);
    vec1 += &vec2;
    assert_eq!(vec1.get(), &vec![5, 7, 9]);
}

#[test]
fn test_sub_assign() {
    let mut vec1 = NumVector::new(vec![4, 5, 6]);
    let vec2 = NumVector::new(vec![1, 2, 3]);
    vec1 -= &vec2;
    assert_eq!(vec1.get(), &vec![3, 3, 3]);
}

#[test]
fn test_mul_assign() {
    let mut vec = NumVector::new(vec![1, 2, 3]);
    vec *= 2;
    assert_eq!(vec.get(), &vec![2, 4, 6]);
}

#[test]
fn test_div_assign() {
    let mut vec = NumVector::new(vec![2, 4, 6]);
    vec /= 2;
    assert_eq!(vec.get(), &vec![1, 2, 3]);
}

#[test]
fn test_empty_vector_operations() {
    let vec1: NumVector<i32> = NumVector::empty();
    let vec2: NumVector<i32> = NumVector::empty();
    assert_eq!((&vec1 + &vec2).get(), &vec![]);
    assert_eq!((&vec1 - &vec2).get(), &vec![]);
}

#[test]
fn test_mixed_operations() {
    let mut vec1 = NumVector::new(vec![10, 20, 30]);
    let vec2 = NumVector::new(vec![1, 2, 3]);
    vec1 += &vec2;
    assert_eq!(vec1.get(), &vec![11, 22, 33]);

    vec1 -= &vec2;
    assert_eq!(vec1.get(), &vec![10, 20, 30]);

    vec1 *= 2;
    assert_eq!(vec1.get(), &vec![20, 40, 60]);

    vec1 /= 2;
    assert_eq!(vec1.get(), &vec![10, 20, 30]);
}

#[test]
fn test_vector_inequality() {
    let vec1 = NumVector::new(vec![1, 2, 3]);
    let vec2 = NumVector::new(vec![4, 5, 6]);
    assert_ne!(vec1, vec2);
}

#[test]
fn test_large_vector_operations() {
    let vec1 = NumVector::new(vec![1; 1000]);
    let vec2 = NumVector::new(vec![2; 1000]);
    let result = &vec1 + &vec2;
    assert_eq!(result.get(), &vec![3; 1000]);

    let result = &vec2 - &vec1;
    assert_eq!(result.get(), &vec![1; 1000]);
}