1use std::{fmt, fmt::{
2 Display,
3 Formatter
4 }, ops::{Add, AddAssign, Div, DivAssign, Index, IndexMut, Mul, MulAssign, Neg, Sub, SubAssign}};
5use num_traits::{identities,pow};
6use crate::{Float, Number, functions::utils::eq_eps_f64};
7use super::{vector3::Vector3, vector4::Vector4};
8use rand::prelude::*;
9use rand::Rng;
10
11
12
13#[macro_export]
14macro_rules! vector {
15 (
16 $($x:expr),*
17 ) => {
18 {
19 Vector::new(vec![
20 $($x),*
21 ])
22 }
23 };
24}
25
26
27
28#[derive(Clone, Debug)]
29pub struct Vector <T:Number> {
30 pub data: Vec<T>
31}
32
33
34
35impl <T: Number> Display for Vector<T> {
36 fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
37
38 let v: Vec<String> = self.data.clone().iter_mut().map(|x| { x.to_string() }).collect();
39
40 write!(f, "\n [{}] \n", v.join(", "))
41 }
42}
43
44
45
46impl <T:Number> Index<usize> for Vector<T> {
47 type Output = T;
48
49 fn index(&self, idx:usize) -> &T {
50 &self.data[idx]
51 }
52}
53
54
55
56impl <T:Number> IndexMut<usize> for Vector<T> {
57 fn index_mut(&mut self, idx:usize) -> &mut T {
58 &mut self.data[idx]
59 }
60}
61
62
63
64impl <T:Number> Vector <T> {
65
66 pub fn new(data: Vec<T>) -> Vector<T> {
67 Vector {
68 data
69 }
70 }
71
72
73
74 pub fn length(&self) -> f64 {
75
76 let result: T = self.data.iter().fold(identities::zero(), |mut sum: T, val: &T| { sum += pow(*val, 2); sum });
77
78 T::to_f64(&result).unwrap().sqrt()
79 }
80
81
82
83 pub fn normalize(&mut self) {
84
85 let l = self.length();
86
87 if l != 0. {
88 *self /= T::from_f64(l).unwrap();
89 }
90
91 }
92
93
94
95 pub fn apply(&mut self, f: fn(&T) -> T) {
96
97 self.data = self.data.iter().map(|x| { f(x) }).collect();
98 }
99
100
101
102 pub fn rand(length: u32, max: Float) -> Vector<T> {
103
104 let mut v: Vector<T> = vector![];
105
106 let mut rng = rand::thread_rng();
107
108 for _i in 0..length {
109 let x: f64 = rng.gen_range(0., max);
110 let x = T::from_f64(x).unwrap();
111 v.data.push(x);
112 }
113
114 v
115 }
116
117
118
119 pub fn zeros(l:usize) -> Vector<T> {
120 let zero = T::from_f64(0.).unwrap();
121 let v = vec![zero;l];
122 Vector::new(v)
123 }
124
125
126
127 pub fn ones(l:usize) -> Vector<T> {
128 let one = T::from_f64(1.).unwrap();
129 let v = vec![one;l];
130 Vector::new(v)
131 }
132
133
134
135 pub fn is_zero(&self) -> bool {
136
137 self.data.iter().all(|x| {
138
139 (T::to_f64(x).unwrap()).abs() < f32::EPSILON as f64
140
141 })
142 }
143}
144
145
146
147fn add<T:Number>(a:&Vector<T>, b:&Vector<T>) -> Vector<T> {
148
149 let zero = identities::zero();
150
151 let mut v: Vector<T> = Vector::new(vec![zero; a.data.len()]);
152
153 for i in 0..a.data.len() {
154 v[i] = a[i] + b[i];
155 }
156
157 v
158}
159
160
161
162fn sub<T:Number>(a:&Vector<T>, b:&Vector<T>) -> Vector<T> {
163
164 let zero = identities::zero();
165
166 let mut v: Vector<T> = Vector::new(vec![zero; a.data.len()]);
167
168 for i in 0..a.data.len() {
169 v[i] = a[i] - b[i];
170 }
171
172 v
173}
174
175
176
177fn mul<T:Number>(a:&Vector<T>, b:&Vector<T>) -> Option<Float> {
178
179 let mut acc: T = identities::zero();
180
181 if a.data.len() != b.data.len() {
182 return None;
183 }
184
185 for i in 0..a.data.len() {
186 acc += a[i] * b[i];
187 }
188
189 T::to_f64(&acc)
190}
191
192
193
194fn scale<T:Number>(a:&Vector<T>, s:T) -> Vector<T> {
195
196 let zero = T::from_f64(0.).unwrap();
197
198 let mut v = Vector::new(vec![zero; a.data.len()]); for i in 0..a.data.len() {
201 v[i] = a[i] * s;
202 }
203
204 v
205}
206
207
208
209impl <T:Number> Add for &Vector<T> {
210 type Output = Vector<T>;
211
212 fn add(self, b:&Vector<T>) -> Vector<T> {
213 add(&self, b)
214 }
215}
216
217
218
219impl <T:Number> Add for Vector<T> {
220 type Output = Vector<T>;
221
222 fn add(self, b:Vector<T>) -> Vector<T> {
223 add(&self, &b)
224 }
225}
226
227
228
229impl <T:Number> Sub for &Vector<T> {
230 type Output = Vector<T>;
231
232 fn sub(self, b:&Vector<T>) -> Vector<T> {
233 sub(&self, b)
234 }
235}
236
237
238
239impl <T:Number> Sub for Vector<T> {
240 type Output = Vector<T>;
241
242 fn sub(self, b:Vector<T>) -> Vector<T> {
243 sub(&self, &b)
244 }
245}
246
247
248
249impl <T:Number> Mul for &Vector<T> {
250 type Output = Float;
251
252 fn mul(self, b:&Vector<T>) -> Float {
253 let result = mul(&self, b);
254 result.unwrap()
255 }
256}
257
258
259
260impl <T:Number> Mul for Vector<T> {
261 type Output = Float;
262
263 fn mul(self, b:Vector<T>) -> Float {
264 let result = mul(&self, &b);
265 result.unwrap()
266 }
267}
268
269
270
271impl <T:Number> Mul <T> for &Vector<T> {
272 type Output = Vector<T>;
273
274 fn mul(self, s:T) -> Vector<T> {
275 scale(&self, s)
276 }
277}
278
279
280
281impl <T:Number> Mul <T> for Vector<T> {
282 type Output = Vector<T>;
283
284 fn mul(self, s:T) -> Vector<T> {
285 scale(&self, s)
286 }
287}
288
289
290
291impl <T:Number> Div <T> for &Vector<T> {
292 type Output = Vector<T>;
293
294 fn div(self, s:T) -> Vector<T> {
295 let one: T = identities::one();
296 let c = one / s;
297 scale(&self, c)
298 }
299}
300
301
302
303impl <T:Number> Div <T> for Vector<T> {
304 type Output = Vector<T>;
305
306 fn div(self, s:T) -> Vector<T> {
307 let one: T = identities::one();
308 let c = one / s;
309 scale(&self, c)
310 }
311}
312
313
314
315impl <T:Number> AddAssign for Vector<T> {
316 fn add_assign(&mut self, b:Vector<T>) {
317 for i in 0..self.data.len() {
318 self[i] = self[i] + b[i];
319 }
320 }
321}
322
323
324
325impl <T:Number> SubAssign for Vector<T> {
326 fn sub_assign(&mut self, b:Vector<T>) {
327 for i in 0..self.data.len() {
328 self[i] = self[i] - b[i];
329 }
330 }
331}
332
333
334
335impl <T:Number> MulAssign <T> for Vector<T> {
336 fn mul_assign(&mut self, s:T) {
337 for i in 0..self.data.len() {
338 self[i] = self[i] * s;
339 }
340 }
341}
342
343
344
345impl <T:Number> DivAssign <T> for Vector<T> {
346 fn div_assign(&mut self, s:T) {
347 for i in 0..self.data.len() {
348 self[i] = self[i] / s;
349 }
350 }
351}
352
353
354
355impl <T:Number> PartialEq for Vector<T> {
356 fn eq(&self, b: &Vector<T>) -> bool {
357
358 if self.data.len() != b.data.len() {
359 return false;
360 }
361
362 for i in 0..self.data.len() {
363 if self[i] != b[i] {
364 return false;
365 }
366 }
367
368 true
369 }
370}
371
372
373
374impl <T:Number> Eq for Vector<T> {}
375
376
377
378impl <T:Number> Neg for Vector<T> {
379 type Output = Vector<T>;
380
381 fn neg(self) -> Vector<T> {
382 let c = T::from_i32(-1).unwrap();
383 scale(&self, c)
384 }
385}
386
387
388
389impl <T:Number> From<&Vector3> for Vector<T> {
390 fn from(v: &Vector3) -> Vector<T> {
391 vector![
392 T::from_f64(v.x).unwrap(),
393 T::from_f64(v.y).unwrap(),
394 T::from_f64(v.z).unwrap()
395 ]
396 }
397}
398
399
400
401impl <T:Number> From<Vector3> for Vector<T> {
402 fn from(v: Vector3) -> Vector<T> {
403 vector![
404 T::from_f64(v.x).unwrap(),
405 T::from_f64(v.y).unwrap(),
406 T::from_f64(v.z).unwrap()
407 ]
408 }
409}
410
411
412
413impl <T:Number> From<&Vector4> for Vector<T> {
414 fn from(v: &Vector4) -> Vector<T> {
415 vector![
416 T::from_f64(v.x).unwrap(),
417 T::from_f64(v.y).unwrap(),
418 T::from_f64(v.z).unwrap(),
419 T::from_f64(v.t).unwrap()
420 ]
421 }
422}
423
424
425
426impl <T:Number> From<Vector4> for Vector<T> {
427 fn from(v: Vector4) -> Vector<T> {
428 vector![
429 T::from_f64(v.x).unwrap(),
430 T::from_f64(v.y).unwrap(),
431 T::from_f64(v.z).unwrap(),
432 T::from_f64(v.t).unwrap()
433 ]
434 }
435}
436
437
438
439mod tests {
440 use std::f64::consts::PI;
441 use super::{
442 Vector,
443 eq_eps_f64
444 };
445
446
447
448 #[test]
449 fn length() {
450
451 let x = vector![1., 1., 1., 1.];
452
453 let l = x.length();
454
455 assert_eq!(2., l, "length should equal 3 {}", l);
456 }
457
458
459
460 #[test]
461 fn normalize() {
462
463 let mut x = vector![77.,34.,2.5,8.9];
464
465 x.normalize();
466
467 let l = x.length();
468
469 assert!(eq_eps_f64(l, 1.), "length should equal 1 {}", l);
470 }
471}