geo-nd 0.6.4

Traits and types particularly for 2D and 3D geometry with implementations for [float] and optionally SIMD
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

//a Imports
use serde::{Deserialize, Serialize};

use super::vector;
use super::{Float, Vector};

//a Macros
//a FArray
//tp FArray
/// The [FArray] is a wrapper around a `D` sized array of [Float]s.
///
/// It provides implementations of the traits required for a [Vector]
/// trait, hence it can be used for a [Vector] of any size `D`.
///
/// Default must be provided separately as it is only implemented
/// for \[F; D\] up to D=32
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(transparent)]
pub struct FArray<F: Float, const D: usize> {
    data: [F; D],
}

//a Macros to implement the traits
//mi farray_basic_traits!
macro_rules! farray_basic_traits {
    { $f:ty,  $e:expr, $ty:ty } => {

        //ip Default for FArray
        impl std::default::Default for $ty {
            fn default() -> Self {
                Self {
                    data: vector::zero(),
                }
            }
        }

        //ip Display for FArray
        impl std::fmt::Display for $ty {
            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
                vector::fmt(f, &self.data)
            }
        }
    }
}

//mi farray_mul_div_traits
macro_rules! farray_mul_div_traits {
    { $f:ty, $e:expr, $ty:ty,
      $trait_op:ident, $fn_op:ident, $op:tt,
      $trait_assign_op:ident, $fn_assign_op:ident, $op_assign:tt  } => {

        // Mul/Div by  $f  for Self
        impl std::ops::$trait_op<$f> for $ty {
            type Output = $ty;
            fn $fn_op(mut self, other: $f) -> $ty {
                for i in 0..$e {
                    self.data[i] $op_assign other;
                }
                self
            }
        }

        impl std::ops::$trait_assign_op<$f> for $ty {
            fn $fn_assign_op(&mut self, other: $f) {
                for i in 0..$e {self.data[i] $op_assign other;}
            }
        }

        // Mul/Div by  & $f  for Self
        impl <'a> std::ops::$trait_op<&'a $f> for $ty {
            type Output = $ty;
            fn $fn_op(mut self, other: &'a $f) -> $ty {
                for i in 0..$e {
                    self.data[i] $op_assign other;
                }
                self
            }
        }

        impl <'a> std::ops::$trait_assign_op<&'a $f> for $ty {
            fn $fn_assign_op(&mut self, other: &'a $f) {
                for i in 0..$e {self.data[i] $op_assign other;}
            }
        }
    }
}

//mi farray_vector_trait
macro_rules! farray_vector_trait {
    { $f:ty,  $e:expr, $ty:ty } => {

        impl Vector<$f, $e> for $ty {
        }

    }
}

//mi farray_traits
macro_rules! farray_traits {
    { $f:ty,  $e:expr, $ty:ty } => {

        farray_basic_traits!{$f, $e, $ty}
        crate::ref_traits!{$f, $e, $ty}
        crate::convert_traits!{$f, $e, $ty}
        crate::unary_traits!{$f, $e, $ty}
        crate::elementwise_traits!{$f, $e, $ty, Add, add, +, AddAssign, add_assign, +=}
        crate::elementwise_traits!{$f, $e, $ty, Sub, sub, -, SubAssign, sub_assign, -=}
        crate::serialize_traits!{$f, $e, $ty}
        farray_mul_div_traits!{$f, $e, $ty, Mul, mul, *, MulAssign, mul_assign, *=}
        farray_mul_div_traits!{$f, $e, $ty, Div, div, /, DivAssign, div_assign, /=}

        farray_vector_trait!{$f, $e, $ty}
    }
}

//mi Invoke farray_traits!
farray_traits! { f32, 2, FArray<f32,2> }
farray_traits! { f32, 3, FArray<f32,3> }
farray_traits! { f32, 4, FArray<f32,4> }
farray_traits! { f32, 5, FArray<f32,5> }
farray_traits! { f32, 6, FArray<f32,6> }
farray_traits! { f32, 7, FArray<f32,7> }
farray_traits! { f32, 8, FArray<f32,8> }
farray_traits! { f32, 9, FArray<f32,9> }
farray_traits! { f32, 10, FArray<f32,10> }
farray_traits! { f32, 11, FArray<f32,11> }
farray_traits! { f32, 12, FArray<f32,12> }
farray_traits! { f32, 13, FArray<f32,13> }
farray_traits! { f32, 14, FArray<f32,14> }
farray_traits! { f32, 15, FArray<f32,15> }
farray_traits! { f32, 16, FArray<f32,16> }

farray_traits! { f64, 2, FArray<f64,2> }
farray_traits! { f64, 3, FArray<f64,3> }
farray_traits! { f64, 4, FArray<f64,4> }
farray_traits! { f64, 5, FArray<f64,5> }
farray_traits! { f64, 6, FArray<f64,6> }
farray_traits! { f64, 7, FArray<f64,7> }
farray_traits! { f64, 8, FArray<f64,8> }
farray_traits! { f64, 9, FArray<f64,9> }
farray_traits! { f64, 10, FArray<f64,10> }
farray_traits! { f64, 11, FArray<f64,11> }
farray_traits! { f64, 12, FArray<f64,12> }
farray_traits! { f64, 13, FArray<f64,13> }
farray_traits! { f64, 14, FArray<f64,14> }
farray_traits! { f64, 15, FArray<f64,15> }
farray_traits! { f64, 16, FArray<f64,16> }