algebrust/
vector.rs

1use rand::{distributions::Uniform, Rng};
2
3pub struct AlgebrustVector {
4    vector: Vec<f64>
5}
6
7impl AlgebrustVector {
8    pub fn new(vector: &[f64]) -> Self {
9        AlgebrustVector { 
10            vector: vector.to_vec()
11        }
12    }
13
14    pub fn new_rand(length: usize, low: f64, high: f64) -> Self {
15        let mut rng = rand::thread_rng();
16        let range = Uniform::new(low, high);
17        let vector: Vec<f64> = (0..length)
18            .map(|_| rng.sample(&range))
19            .collect();
20        AlgebrustVector { vector }
21    }
22
23    pub fn new_zeros(length: usize) -> Self {
24        let vector = vec![0.0; length];
25        AlgebrustVector { vector }
26    }
27
28    pub fn len(&self) -> usize {
29        self.vector.len()
30    }
31
32    pub fn vector_ref(&self) -> &Vec<f64> {
33        &self.vector
34    }
35
36    pub fn addition(&self, other: &AlgebrustVector) -> AlgebrustVector {
37        assert_eq!(self.len(), other.len());
38        let vector: Vec<f64> = self.vector
39            .iter()
40            .zip(&other.vector)
41            .map(|(a, b)| a + b)
42            .collect();
43        AlgebrustVector { vector }
44    }
45
46    pub fn subtraction(&self, other: &AlgebrustVector) -> AlgebrustVector {
47        assert_eq!(self.len(), other.len());
48        let vector: Vec<f64> = self.vector
49            .iter()
50            .zip(&other.vector)
51            .map(|(a, b)| a - b)
52            .collect();
53        AlgebrustVector { vector }
54    }
55
56    pub fn dot_product(&self, other: &AlgebrustVector) -> f64 {
57        assert_eq!(self.len(), other.len());
58        self.vector
59            .iter()
60            .zip(&other.vector)
61            .map(|(a, b)| a * b)
62            .sum()
63    }
64
65    pub fn scalar_multiplication(&self, scaler: f64) -> AlgebrustVector {
66        let vector: Vec<f64> = self.vector
67            .iter()
68            .map(|a| a * scaler)
69            .collect();
70        AlgebrustVector { vector }
71    }
72
73    pub fn magnitude(&self) -> f64 {
74        let squared_sum: f64 = self.vector
75            .iter()
76            .map(|a| a * a)
77            .sum();
78        squared_sum.sqrt()
79    }
80
81    pub fn normalization(&self) -> AlgebrustVector {
82        let magnitude = self.magnitude();
83        let vector: Vec<f64> = self.vector
84            .iter()
85            .map(|a| a / magnitude)
86            .collect();
87        AlgebrustVector { vector }
88    }
89
90    pub fn cross_product(&self, other: &AlgebrustVector) -> AlgebrustVector {
91        assert_eq!((self.len(), other.len()), (3, 3));
92        AlgebrustVector { 
93            vector: vec![
94                (self.vector[1] * other.vector[2]) - (self.vector[2] * other.vector[1]),
95                (self.vector[2] * other.vector[0]) - (self.vector[0] * other.vector[2]),
96                (self.vector[0] * other.vector[1]) - (self.vector[1] * other.vector[0])
97            ] 
98        }
99    }
100}
algebrust/vector.rs

algebrust/
vector.rs
