ngeom-macros 0.1.0

Internal proc-macro crate for ngeom
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

pub trait Dual {
    type Dual: Dual<Dual = Self>;
}

pub mod pga2d {
    use crate::Dual;
    use core::ops::BitAnd;

    pub struct Vector {
        _x: f32,
        _y: f32,
        _z: f32,
    }

    pub struct Bivector {
        _x: f32,
        _y: f32,
        _z: f32,
    }

    pub struct Pseudoscalar {
        _x: f32,
    }

    impl BitAnd<Bivector> for Bivector {
        type Output = Vector;

        fn bitand(self, _x: Bivector) -> Vector {
            Vector {
                _x: 0.,
                _y: 0.,
                _z: 0.,
            }
        }
    }

    impl Dual for Vector {
        type Dual = Bivector;
    }

    impl Dual for Bivector {
        type Dual = Vector;
    }
}
pub mod pga3d {
    use crate::Dual;
    use core::ops::BitAnd;

    pub struct Vector {
        _x: f32,
        _y: f32,
        _z: f32,
        _w: f32,
    }

    pub struct Bivector {
        _x: f32,
        _y: f32,
        _z: f32,
        _a: f32,
        _b: f32,
        _c: f32,
    }

    pub struct Trivector {
        _x: f32,
        _y: f32,
        _z: f32,
        _w: f32,
    }

    pub struct Pseudoscalar {
        _x: f32,
    }

    impl BitAnd<Trivector> for Trivector {
        type Output = Bivector;

        fn bitand(self, _x: Trivector) -> Bivector {
            Bivector {
                _x: 0.,
                _y: 0.,
                _z: 0.,
                _a: 0.,
                _b: 0.,
                _c: 0.,
            }
        }
    }

    impl Dual for Vector {
        type Dual = Trivector;
    }

    impl Dual for Bivector {
        type Dual = Bivector;
    }

    impl Dual for Trivector {
        type Dual = Vector;
    }
}

pub fn vee_3d(
    a: <pga3d::Vector as Dual>::Dual,
    b: <pga3d::Vector as Dual>::Dual,
) -> <pga3d::Bivector as Dual>::Dual {
    a & b
}

pub fn vee_2d(
    a: <pga2d::Vector as Dual>::Dual,
    b: <pga2d::Vector as Dual>::Dual,
) -> <pga2d::Bivector as Dual>::Dual {
    a & b
}

pub trait PGA {
    type Point: BitAnd<Self::Point, Output = Self::Line>;
    type Line;
}

struct PGA3D;
struct PGA2D;

impl PGA for PGA3D {
    type Point = pga3d::Trivector;
    type Line = pga3d::Bivector;
}

impl PGA for PGA2D {
    type Point = pga2d::Bivector;
    type Line = pga2d::Vector;
}

use core::ops::BitAnd;
pub fn vee<A: PGA>(a: A::Point, b: A::Point) -> A::Line {
    a & b
}

#[cfg(test)]
mod test {
    use super::*;

    fn test_algebra() {}
}