cubi_vectors 0.2.1

A Simple Vector library
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

#[macro_export]
macro_rules! vector_base {
     ($vector_name:ident<$component_type: ty> {$($component:ident),*}) => {
          #[derive(Copy, Clone, PartialEq, Debug)]
          pub struct $vector_name {
               $( pub $component: $component_type, )*
          }

          impl Add for $vector_name {
               type Output = $vector_name;

               fn add(self, rhs: Self) -> Self::Output {
                    $vector_name { $($component: self.$component + rhs.$component, )* }
               }
          }

          impl AddAssign for $vector_name {
               fn add_assign(&mut self, rhs: Self) {
                    $(self.$component += rhs.$component;)*
               }
          }

          impl Sub for $vector_name {
               type Output = $vector_name;

               fn sub(self, rhs: Self) -> Self::Output {
                    $vector_name { $($component: self.$component - rhs.$component, )* }
               }
          }

          impl SubAssign for $vector_name {
               fn sub_assign(&mut self, rhs: Self) {
                    $(self.$component -= rhs.$component;)*
               }
          }

          impl Mul<$component_type> for $vector_name {
               type Output = $vector_name;

               fn mul(self, rhs: $component_type) -> Self::Output {
                    $vector_name { $($component: self.$component * rhs, )* }
               }
          }

          impl Mul<$vector_name> for $component_type {
               type Output = $vector_name;

               fn mul(self, rhs: $vector_name) -> Self::Output {
                    $vector_name { $($component: self * rhs.$component, )* }
               }
          }

          impl MulAssign<$component_type> for $vector_name {
               fn mul_assign(&mut self, rhs: $component_type) {
                    $(self.$component *= rhs;)*
               }
          }

          impl Div<$component_type> for $vector_name {
               type Output = $vector_name;

               fn div(self, rhs: $component_type) -> Self::Output {
                    $vector_name { $($component: self.$component / rhs, )* }
               }
          }

          impl DivAssign<$component_type> for $vector_name {
               fn div_assign(&mut self, rhs: $component_type) {
                    $(self.$component /= rhs;)*
               }
          }

          impl Neg for $vector_name {
               type Output = $vector_name;

               fn neg(self) -> Self::Output {
                    $vector_name { $($component: -self.$component, )* }
               }
          }
     };
}