maph 0.8.1

Maths package for use with personal stuff, but like, you can totally use it! If you want! There's even some light documentation now!
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237

use super::{rational::*};
use std::{ops::{Mul, MulAssign, Div, DivAssign, Neg}, fmt::{Display, Formatter}};

///Surd Type using 32 bit components - composed of a rational coefficient and a u32 radicand - i.e.
///for coefficient A and radicand B, this is A * sqrt(B); Cannot be Added or Subtracted, but can be multiplied and divided.
#[allow(non_camel_case_types)]
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub struct surd32 {
    ///Rational coefficient.
    pub coef: r32,
    ///Radicand.
    pub radicand: u32,
}
impl surd32 {
    ///Returns a new, simplified surd based on coefficient and radicand.
    pub fn new(coef: r32, radicand: u32) -> Self {
        if radicand == 0 { panic!("Radicand for a Surd should never be 0."); }
        let factors = super::factors::sqfac32(radicand);
        let sq_sum = factors.iter().map(|(s, _sq)| s).product::<u32>();
        Self { coef: coef * sq_sum, radicand: radicand / (sq_sum * sq_sum) }
    }
    ///Returns the coefficient of the surd.
    pub fn coef(&self) -> r32 { self.coef }
    ///Returns the radicand of the surd.
    pub fn radicand(&self) -> u32 { self.radicand }
    ///Tries to convert the surd to a rational number - only possible if the radicand is 1.
    pub fn rational(&self) -> Option<r32> { match self.radicand == 1 {
        true => Some(self.coef), false => None
    }}
    ///Returns the squared surd as a rational number - surds squared are always rational.
    pub fn squared(&self) -> r32 { (self * self).rational().expect("A squared surd should always return a rational number.") }
}
impl From<f32> for surd32 {
    fn from(other: f32) -> Self {
        Self::new(r32::from(other), 1)
    }   
}
impl From<surd32> for f32 {
    fn from(other: surd32) -> f32 {
        f32::from(other.coef) * (other.radicand as f32).sqrt()
    }
}
impl From<r32> for surd32 {
    fn from(other: r32) -> Self {
        Self::new(other, 1)
    }
}
impl From<surd32> for r32 {
    fn from(other: surd32) -> Self {
        other.coef * r32::from((other.radicand as f32).sqrt())
    }
}
impl Display for surd32 {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "({})*sqrt({})", self.coef, self.radicand)
    }
}
impl Mul<surd32> for surd32 {
    type Output = surd32;
    fn mul(self, other: surd32) -> surd32 {
        Self::new(self.coef * other.coef, self.radicand * other.radicand)
    }
}
impl Div<surd32> for surd32 {
    type Output = surd32;
    fn div(self, other: surd32) -> surd32 {
        Self::new(self.coef / other.coef, self.radicand / other.radicand)
    }
}
impl Mul<u32> for surd32 {
    type Output = surd32;
    fn mul(self, other: u32) -> surd32 { Self::new(self.coef * other, self.radicand) }
}
impl Mul<i32> for surd32 {
    type Output = surd32;
    fn mul(self, other: i32) -> surd32 { Self::new(self.coef * other, self.radicand) }
}
impl Div<u32> for surd32 {
    type Output = surd32;
    fn div(self, other: u32) -> surd32 { Self::new(self.coef / other, self.radicand) }
}
impl Div<i32> for surd32 {
    type Output = surd32;
    fn div(self, other: i32) -> surd32 { Self::new(self.coef / other, self.radicand) }
}
impl Neg for surd32 {
    type Output = surd32;
    fn neg(self) -> surd32 { Self::new(-self.coef, self.radicand) }
}
impl Mul<&surd32> for surd32 { type Output = surd32; fn mul(self, other: &surd32) -> surd32 { self * *other } }
impl Mul<surd32> for &surd32 { type Output = surd32; fn mul(self, other: surd32) -> surd32 { *self * other } }
impl Mul<&surd32> for &surd32 { type Output = surd32; fn mul(self, other: &surd32) -> surd32 { *self * *other } }
impl MulAssign<surd32> for surd32 { fn mul_assign(&mut self, other: surd32) { *self = *self * other; } }
impl MulAssign<&surd32> for surd32 { fn mul_assign(&mut self, other: &surd32) { *self = *self * other; } }
impl Div<&surd32> for surd32 { type Output = surd32; fn div(self, other: &surd32) -> surd32 { self / *other } }
impl Div<surd32> for &surd32 { type Output = surd32; fn div(self, other: surd32) -> surd32 { *self / other } }
impl Div<&surd32> for &surd32 { type Output = surd32; fn div(self, other: &surd32) -> surd32 { *self / *other } }
impl DivAssign<surd32> for surd32 { fn div_assign(&mut self, other: surd32) { *self = *self / other; } }
impl DivAssign<&surd32> for surd32 { fn div_assign(&mut self, other: &surd32) { *self = *self / other; } }
impl Mul<&i32> for surd32 { type Output = surd32; fn mul(self, other: &i32) -> surd32 { self * *other } }
impl Mul<i32> for &surd32 { type Output = surd32; fn mul(self, other: i32) -> surd32 { *self * other } }
impl Mul<&i32> for &surd32 { type Output = surd32; fn mul(self, other: &i32) -> surd32 { *self * *other } }
impl MulAssign<i32> for surd32 { fn mul_assign(&mut self, other: i32) { *self = *self * other; } }
impl MulAssign<&i32> for surd32 { fn mul_assign(&mut self, other: &i32) { *self = *self * other; } }
impl Div<&i32> for surd32 { type Output = surd32; fn div(self, other: &i32) -> surd32 { self / *other } }
impl Div<i32> for &surd32 { type Output = surd32; fn div(self, other: i32) -> surd32 { *self / other } }
impl Div<&i32> for &surd32 { type Output = surd32; fn div(self, other: &i32) -> surd32 { *self / *other } }
impl DivAssign<i32> for surd32 { fn div_assign(&mut self, other: i32) { *self = *self / other; } }
impl DivAssign<&i32> for surd32 { fn div_assign(&mut self, other: &i32) { *self = *self / other; } }
impl Mul<&u32> for surd32 { type Output = surd32; fn mul(self, other: &u32) -> surd32 { self * *other } }
impl Mul<u32> for &surd32 { type Output = surd32; fn mul(self, other: u32) -> surd32 { *self * other } }
impl Mul<&u32> for &surd32 { type Output = surd32; fn mul(self, other: &u32) -> surd32 { *self * *other } }
impl MulAssign<u32> for surd32 { fn mul_assign(&mut self, other: u32) { *self = *self * other; } }
impl MulAssign<&u32> for surd32 { fn mul_assign(&mut self, other: &u32) { *self = *self * other; } }
impl Div<&u32> for surd32 { type Output = surd32; fn div(self, other: &u32) -> surd32 { self / *other } }
impl Div<u32> for &surd32 { type Output = surd32; fn div(self, other: u32) -> surd32 { *self / other } }
impl Div<&u32> for &surd32 { type Output = surd32; fn div(self, other: &u32) -> surd32 { *self / *other } }
impl DivAssign<u32> for surd32 { fn div_assign(&mut self, other: u32) { *self = *self / other; } }
impl DivAssign<&u32> for surd32 { fn div_assign(&mut self, other: &u32) { *self = *self / other; } }


///Surd Type using 64 bit components - composed of a rational coefficient and a u32 radicand - i.e.
///for coefficient A and radicand B, this is A * sqrt(B); Cannot be Added or Subtracted, but can be multiplied and divided.
#[allow(non_camel_case_types)]
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub struct surd64 {
    ///Rational coefficient.
    pub coef: r64,
    ///Radicand.
    pub radicand: u64,
}
impl surd64 {
    ///Returns a new, simplified surd based on coefficient and radicand.
    pub fn new(coef: r64, radicand: u64) -> Self {
        if radicand == 0 { panic!("Radicand for a Surd should never be 0."); }
        let factors = super::factors::sqfac64(radicand);
        let sq_sum = factors.iter().map(|(s, _sq)| s).product::<u64>();
        Self { coef: coef * sq_sum, radicand: radicand / (sq_sum * sq_sum) }
    }
    ///Returns the coefficient of the surd.
    pub fn coef(&self) -> r64 { self.coef }
    ///Returns the radicand of the surd.
    pub fn radicand(&self) -> u64 { self.radicand }
    ///Tries to convert the surd to a rational number - only possible if the radicand is 1.
    pub fn rational(&self) -> Option<r64> { match self.radicand == 1 {
        true => Some(self.coef), false => None
    }}
    ///Returns the squared surd as a rational number - surds squared are always rational.
    pub fn squared(&self) -> r64 { (self * self).rational().expect("A squared surd should always return a rational number.") }
}
impl From<f64> for surd64 {
    fn from(other: f64) -> Self {
        Self::new(r64::from(other), 1)
    }   
}
impl From<surd64> for f64 {
    fn from(other: surd64) -> f64 {
        f64::from(other.coef) * (other.radicand as f64).sqrt()
    }
}
impl From<r64> for surd64 {
    fn from(other: r64) -> Self {
        Self::new(other, 1)
    }
}
impl From<surd64> for r64 {
    fn from(other: surd64) -> Self {
        other.coef * r64::from((other.radicand as f64).sqrt())
    }
}
impl Display for surd64 {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "({})*sqrt({})", self.coef, self.radicand)
    }
}
impl Mul<surd64> for surd64 {
    type Output = surd64;
    fn mul(self, other: surd64) -> surd64 {
        Self::new(self.coef * other.coef, self.radicand * other.radicand)
    }
}
impl Div<surd64> for surd64 {
    type Output = surd64;
    fn div(self, other: surd64) -> surd64 {
        Self::new(self.coef / other.coef, self.radicand / other.radicand)
    }
}
impl Mul<u64> for surd64 {
    type Output = surd64;
    fn mul(self, other: u64) -> surd64 { Self::new(self.coef * other, self.radicand) }
}
impl Mul<i64> for surd64 {
    type Output = surd64;
    fn mul(self, other: i64) -> surd64 { Self::new(self.coef * other, self.radicand) }
}
impl Div<u64> for surd64 {
    type Output = surd64;
    fn div(self, other: u64) -> surd64 { Self::new(self.coef / other, self.radicand) }
}
impl Div<i64> for surd64 {
    type Output = surd64;
    fn div(self, other: i64) -> surd64 { Self::new(self.coef / other, self.radicand) }
}
impl Neg for surd64 {
    type Output = surd64;
    fn neg(self) -> surd64 { Self::new(-self.coef, self.radicand) }
}
impl Mul<&surd64> for surd64 { type Output = surd64; fn mul(self, other: &surd64) -> surd64 { self * *other } }
impl Mul<surd64> for &surd64 { type Output = surd64; fn mul(self, other: surd64) -> surd64 { *self * other } }
impl Mul<&surd64> for &surd64 { type Output = surd64; fn mul(self, other: &surd64) -> surd64 { *self * *other } }
impl MulAssign<surd64> for surd64 { fn mul_assign(&mut self, other: surd64) { *self = *self * other; } }
impl MulAssign<&surd64> for surd64 { fn mul_assign(&mut self, other: &surd64) { *self = *self * other; } }
impl Div<&surd64> for surd64 { type Output = surd64; fn div(self, other: &surd64) -> surd64 { self / *other } }
impl Div<surd64> for &surd64 { type Output = surd64; fn div(self, other: surd64) -> surd64 { *self / other } }
impl Div<&surd64> for &surd64 { type Output = surd64; fn div(self, other: &surd64) -> surd64 { *self / *other } }
impl DivAssign<surd64> for surd64 { fn div_assign(&mut self, other: surd64) { *self = *self / other; } }
impl DivAssign<&surd64> for surd64 { fn div_assign(&mut self, other: &surd64) { *self = *self / other; } }
impl Mul<&i64> for surd64 { type Output = surd64; fn mul(self, other: &i64) -> surd64 { self * *other } }
impl Mul<i64> for &surd64 { type Output = surd64; fn mul(self, other: i64) -> surd64 { *self * other } }
impl Mul<&i64> for &surd64 { type Output = surd64; fn mul(self, other: &i64) -> surd64 { *self * *other } }
impl MulAssign<i64> for surd64 { fn mul_assign(&mut self, other: i64) { *self = *self * other; } }
impl MulAssign<&i64> for surd64 { fn mul_assign(&mut self, other: &i64) { *self = *self * other; } }
impl Div<&i64> for surd64 { type Output = surd64; fn div(self, other: &i64) -> surd64 { self / *other } }
impl Div<i64> for &surd64 { type Output = surd64; fn div(self, other: i64) -> surd64 { *self / other } }
impl Div<&i64> for &surd64 { type Output = surd64; fn div(self, other: &i64) -> surd64 { *self / *other } }
impl DivAssign<i64> for surd64 { fn div_assign(&mut self, other: i64) { *self = *self / other; } }
impl DivAssign<&i64> for surd64 { fn div_assign(&mut self, other: &i64) { *self = *self / other; } }
impl Mul<&u64> for surd64 { type Output = surd64; fn mul(self, other: &u64) -> surd64 { self * *other } }
impl Mul<u64> for &surd64 { type Output = surd64; fn mul(self, other: u64) -> surd64 { *self * other } }
impl Mul<&u64> for &surd64 { type Output = surd64; fn mul(self, other: &u64) -> surd64 { *self * *other } }
impl MulAssign<u64> for surd64 { fn mul_assign(&mut self, other: u64) { *self = *self * other; } }
impl MulAssign<&u64> for surd64 { fn mul_assign(&mut self, other: &u64) { *self = *self * other; } }
impl Div<&u64> for surd64 { type Output = surd64; fn div(self, other: &u64) -> surd64 { self / *other } }
impl Div<u64> for &surd64 { type Output = surd64; fn div(self, other: u64) -> surd64 { *self / other } }
impl Div<&u64> for &surd64 { type Output = surd64; fn div(self, other: &u64) -> surd64 { *self / *other } }
impl DivAssign<u64> for surd64 { fn div_assign(&mut self, other: u64) { *self = *self / other; } }
impl DivAssign<&u64> for surd64 { fn div_assign(&mut self, other: &u64) { *self = *self / other; } }