hexglobe 0.1.3

Library to generate hexagonal tessellations of a sphere quickly and accurately.
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

use std::fmt::{Debug, Formatter};
use std::ops::{Add, Deref, Div, Mul, Sub};

/// Helper struct which stores the denominator of a fraction within the type. Not strictly necessary but helps
/// tremendously with readability and maintainability. Implements passthroughs for various common (in this library)
/// arithmetic methods.
#[derive(Copy, Clone, PartialEq, Eq, Hash)]
pub struct ImplicitDenominator<T, const N: u32>(T);

impl<T, const N: u32> ImplicitDenominator<T, N> {
    /// Create a new fraction with denominator `N`.
    pub fn new(value: T) -> Self {
        Self(value)
    }
}

impl<T, const N: u32> Deref for ImplicitDenominator<T, N> {
    type Target = T;
    
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<T, const N: u32> ImplicitDenominator<T, N> {
    pub const fn wrap(v: T) -> Self {
        Self(v)
    }
    
    pub const fn inner(&self) -> T where T: Copy {
        self.0
    }
}

impl<T, const N: u32> Debug for ImplicitDenominator<T, N> where
    T : Debug {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}/{:?}", self.0, N)
    }
}

impl<T, U, const N: u32> Add<ImplicitDenominator<U, N>> for ImplicitDenominator<T, N> where
    T : Add<U> {
    type Output = ImplicitDenominator<<T as Add<U>>::Output, N>;
    
    fn add(self, rhs: ImplicitDenominator<U, N>) -> Self::Output {
        ImplicitDenominator(self.0 + rhs.0)
    }
}

impl<'a, T, U, const N: u32> Add<&'a ImplicitDenominator<U, N>> for ImplicitDenominator<T, N> where
    T : Add<U>,
    U : Clone {
    type Output = ImplicitDenominator<<T as Add<U>>::Output, N>;
    
    fn add(self, rhs: &'a ImplicitDenominator<U, N>) -> Self::Output {
        ImplicitDenominator(self.0 + rhs.0.clone())
    }
}

impl<'a, T, U, const N: u32> Add<ImplicitDenominator<U, N>> for &'a ImplicitDenominator<T, N> where
    T : Add<U> + Clone {
    type Output = ImplicitDenominator<<T as Add<U>>::Output, N>;
    
    fn add(self, rhs: ImplicitDenominator<U, N>) -> Self::Output {
        ImplicitDenominator(self.0.clone() + rhs.0)
    }
}

impl<'a, 'b, T, U, const N: u32> Add<&'a ImplicitDenominator<U, N>> for &'b ImplicitDenominator<T, N> where
    T : Add<U> + Clone,
    U : Clone {
    type Output = ImplicitDenominator<<T as Add<U>>::Output, N>;
    
    fn add(self, rhs: &'a ImplicitDenominator<U, N>) -> Self::Output {
        ImplicitDenominator(self.0.clone() + rhs.0.clone())
    }
}

impl<T, U, const N: u32> Sub<ImplicitDenominator<U, N>> for ImplicitDenominator<T, N> where
    T : Sub<U> {
    type Output = ImplicitDenominator<<T as Sub<U>>::Output, N>;
    
    fn sub(self, rhs: ImplicitDenominator<U, N>) -> Self::Output {
        ImplicitDenominator(self.0 - rhs.0)
    }
}

impl<'a, T, U, const N: u32> Sub<&'a ImplicitDenominator<U, N>> for ImplicitDenominator<T, N> where
    T : Sub<U>,
    U : Clone {
    type Output = ImplicitDenominator<<T as Sub<U>>::Output, N>;
    
    fn sub(self, rhs: &'a ImplicitDenominator<U, N>) -> Self::Output {
        ImplicitDenominator(self.0 - rhs.0.clone())
    }
}

impl<'a, T, U, const N: u32> Sub<ImplicitDenominator<U, N>> for &'a ImplicitDenominator<T, N> where
    T : Sub<U> + Clone {
    type Output = ImplicitDenominator<<T as Sub<U>>::Output, N>;
    
    fn sub(self, rhs: ImplicitDenominator<U, N>) -> Self::Output {
        ImplicitDenominator(self.0.clone() - rhs.0)
    }
}

impl<'a, 'b, T, U, const N: u32> Sub<&'a ImplicitDenominator<U, N>> for &'b ImplicitDenominator<T, N> where
    T : Sub<U> + Clone,
    U : Clone {
    type Output = ImplicitDenominator<<T as Sub<U>>::Output, N>;
    
    fn sub(self, rhs: &'a ImplicitDenominator<U, N>) -> Self::Output {
        ImplicitDenominator(self.0.clone() - rhs.0.clone())
    }
}

impl<T, U, const N: u32> Mul<U> for ImplicitDenominator<T, N> where
    T : Mul<U> {
    type Output = ImplicitDenominator<<T as Mul<U>>::Output, N>;
    
    fn mul(self, rhs: U) -> Self::Output {
        ImplicitDenominator(self.0 * rhs)
    }
}

impl<'a, T, U, const N: u32> Mul<U> for &'a ImplicitDenominator<T, N> where
    T : Mul<U> + Clone {
    type Output = ImplicitDenominator<<T as Mul<U>>::Output, N>;
    
    fn mul(self, rhs: U) -> Self::Output {
        ImplicitDenominator(self.0.clone() * rhs)
    }
}

impl<T, U, const N: u32> Div<U> for ImplicitDenominator<T, N> where
    T : Div<U> {
    type Output = ImplicitDenominator<<T as Div<U>>::Output, N>;
    
    fn div(self, rhs: U) -> Self::Output {
        ImplicitDenominator(self.0 / rhs)
    }
}