abels_complex/complex/f32/
polar.rs1use core::f32::consts::{FRAC_PI_2, PI};
2use core::ops::*;
3
4type Polar = crate::complex::polar::ComplexPolar<FT>;
5type FT = f32;
6
7impl Mul<Polar> for FT {
8 type Output = Polar;
9 fn mul(self, mut other: Self::Output) -> Self::Output {
10 other *= self;
11 other
12 }
13}
14
15impl Div<Polar> for FT {
16 type Output = Polar;
17 fn div(self, other: Self::Output) -> Self::Output {
18 self * other.recip()
19 }
20}
21
22impl Polar {
23 pub const I: Self = Self::new(1.0, FRAC_PI_2);
24 pub const NEG_ONE: Self = Self::new(1.0, PI);
25 pub const NEG_I: Self = Self::new(1.0, -FRAC_PI_2);
26}
27
28#[cfg(feature = "rand")]
29impl rand::distr::Distribution<Polar> for rand::distr::StandardUniform {
30 fn sample<R: rand::Rng + ?Sized>(&self, rng: &mut R) -> Polar {
31 use rand::RngExt;
32 Polar::new(self.sample(rng), rng.random_range((-PI).next_up()..=PI))
33 }
34}
35
36#[cfg(test)]
37mod tests {
38 use super::*;
39 use approx::*;
40 use core::f32::consts::{E, LN_2, TAU};
41 use rand::{
42 RngExt, SeedableRng,
43 distr::{Distribution, StandardUniform, Uniform, uniform::*},
44 rngs::StdRng,
45 };
46
47 type Rectangular = crate::complex::rectangular::Complex<FT>;
48
49 const NUM_SAMPLES: usize = 100;
50 const SEED: u64 = 21;
51
52 fn random_samples<T>() -> impl core::iter::Iterator<Item = T>
53 where
54 StandardUniform: Distribution<T>,
55 {
56 StdRng::seed_from_u64(SEED)
57 .sample_iter(StandardUniform)
58 .take(NUM_SAMPLES)
59 }
60
61 fn uniform_samples<T>(low: T, high: T) -> impl core::iter::Iterator<Item = T>
62 where
63 T: SampleUniform,
64 {
65 StdRng::seed_from_u64(SEED)
66 .sample_iter(Uniform::new(low, high).unwrap())
67 .take(NUM_SAMPLES)
68 }
69
70 #[test]
71 fn multiplication() {
72 for z0 in random_samples::<Polar>() {
73 for z1 in random_samples::<Polar>() {
74 let z = z0 * z1;
75 assert_eq!(z.abs, z0.abs * z1.abs);
76 assert_eq!(z.arg, z0.arg + z1.arg);
77
78 let z = z0 * z1.re();
79 assert_eq!(z.normalize().abs, z0.abs * z1.re().abs());
80 assert_eq!(z.arg, z0.arg);
81
82 let z = z0.re() * z1;
83 assert_eq!(z.normalize().abs, z0.re().abs() * z1.abs);
84 assert_eq!(z.arg, z1.arg);
85
86 let mut z = z0;
87 z *= z1;
88 assert_eq!(z, z0 * z1);
89
90 let mut z = z0;
91 z *= z1.re();
92 assert_eq!(z, z0 * z1.re());
93 }
94 assert_eq!(z0 * Polar::ONE, z0);
95 assert_eq!((z0 * Polar::ZERO).abs, 0.0);
96 assert_eq!((z0 * 0.0).abs, 0.0);
97 }
98 }
99
100 #[test]
101 fn division() {
102 for z0 in random_samples::<Polar>() {
103 for z1 in random_samples::<Polar>() {
104 let z = z0 / z1;
105 assert_ulps_eq!(z.abs, z0.abs / z1.abs);
106 assert_ulps_eq!(z.arg, z0.arg - z1.arg);
107
108 let z = z0 / z1.re();
109 assert_ulps_eq!(z.normalize().abs, z0.abs / z1.re().abs());
110 assert_ulps_eq!(z.arg, z0.arg);
111
112 let z = z0.re() / z1;
113 assert_ulps_eq!(z.normalize().abs, z0.re().abs() / z1.abs);
114 assert_ulps_eq!(z.arg, -z1.arg);
115
116 let mut z = z0;
117 z /= z1;
118 assert_eq!(z, z0 / z1);
119
120 let mut z = z0;
121 z /= z1.re();
122 assert_eq!(z, z0 / z1.re());
123 }
124 assert_ulps_eq!(z0 / z0, Polar::ONE);
125 assert_eq!((Polar::ZERO / z0).abs, 0.0);
126 }
127 }
128
129 #[test]
130 fn negation() {
131 assert_eq!((-Polar::ONE).normalize(), Polar::NEG_ONE);
132 assert_eq!((-Polar::I).normalize(), Polar::NEG_I);
133 assert_eq!((-Polar::NEG_ONE).normalize(), Polar::ONE);
134 assert_ulps_eq!((-Polar::NEG_I).normalize(), Polar::I);
135 }
136
137 #[test]
138 fn reciprocal() {
139 for z in random_samples::<Polar>() {
140 assert_ulps_eq!(z.recip(), 1.0 / z);
141 assert_ulps_eq!(z * z.recip(), Polar::ONE);
142 }
143 assert_eq!(Polar::ONE.recip(), Polar::ONE);
144 assert_eq!(Polar::I.recip(), Polar::NEG_I);
145 assert_eq!(Polar::NEG_ONE.recip().normalize(), Polar::NEG_ONE);
146 assert_eq!(Polar::NEG_I.recip(), Polar::I);
147 }
148
149 #[test]
150 fn sqrt() {
151 for z in random_samples::<Polar>() {
152 assert_eq!(z.sqrt().abs, z.abs.sqrt());
153 assert_eq!(z.sqrt().arg, z.arg / 2.0);
154 }
155 assert_eq!(Polar::ONE.sqrt(), Polar::ONE);
156 assert_eq!(Polar::NEG_ONE.sqrt(), Polar::I);
157 assert_eq!(Polar::ONE.sqrt(), Polar::ONE);
158 }
159
160 #[test]
161 fn abs() {
162 for z in random_samples::<Polar>() {
163 assert_eq!(z.abs_sq(), z.abs * z.abs);
164 }
165 assert_eq!(Polar::ONE.abs, 1.0);
166 assert_eq!(Polar::I.abs, 1.0);
167 assert_eq!(Polar::NEG_ONE.abs, 1.0);
168 assert_eq!(Polar::NEG_I.abs, 1.0);
169 }
170
171 #[test]
172 fn conjugate() {
173 for z in random_samples::<Polar>() {
174 assert_eq!(z.conjugate().re(), z.re());
175 assert_eq!(z.conjugate().im(), -z.im());
176 assert_eq!(z.conjugate().conjugate(), z);
177 }
178 assert_ulps_eq!(Polar::ONE.conjugate().normalize(), Polar::ONE);
179 assert_ulps_eq!(Polar::I.conjugate().normalize(), Polar::NEG_I);
180 assert_ulps_eq!(Polar::NEG_ONE.conjugate().normalize(), Polar::NEG_ONE);
181 assert_ulps_eq!(Polar::NEG_I.conjugate().normalize(), Polar::I);
182 }
183
184 #[test]
185 fn arg() {
186 assert_eq!(Polar::ONE.arg, 0.0);
187 assert_eq!(Polar::I.arg, FRAC_PI_2);
188 assert_eq!(Polar::NEG_ONE.arg, PI);
189 assert_eq!(Polar::NEG_I.arg, -FRAC_PI_2);
190 }
191
192 #[test]
193 fn exp() {
194 for z in random_samples::<Polar>() {
195 assert_eq!(z.exp().abs, z.re().exp());
196 assert_eq!(z.exp().arg, z.im());
197 assert_ulps_eq!(z.exp().ln(), z.to_rectangular());
198 }
199 assert_ulps_eq!(Polar::ONE.exp(), Polar::new(E, 0.0));
200 assert_ulps_eq!(Polar::I.exp(), Polar::new(1.0, 1.0));
201 assert_ulps_eq!(Polar::NEG_ONE.exp(), Polar::new(E.recip(), 0.0));
202 assert_ulps_eq!(Polar::NEG_I.exp(), Polar::new(1.0, -1.0));
203 }
204
205 #[test]
206 fn exp2() {
207 for z in random_samples::<Polar>() {
208 assert_eq!(z.exp2().abs, z.re().exp2());
209 assert_eq!(z.exp2().arg, z.im() * LN_2);
210 assert_ulps_eq!(z.exp2().log2(), z.to_rectangular());
211 }
212 assert_eq!(Polar::ONE.exp2(), Polar::new(2.0, 0.0));
213 assert_ulps_eq!(Polar::I.exp2(), Polar::new(1.0, LN_2));
214 assert_ulps_eq!(Polar::NEG_ONE.exp2(), Polar::new(0.5, 0.0));
215 assert_ulps_eq!(Polar::NEG_I.exp2(), Polar::new(1.0, -LN_2));
216 }
217
218 #[test]
219 fn log() {
220 for z in random_samples::<Polar>() {
221 assert_eq!(z.ln().re, z.abs.ln());
222 assert_eq!(z.ln().im, z.arg);
223 assert_ulps_eq!(z.ln().exp(), z);
224 }
225 assert_eq!(Polar::ONE.ln(), Rectangular::ZERO);
226 assert_eq!(Polar::I.ln(), Rectangular::I * FRAC_PI_2);
227 assert_eq!(Polar::NEG_ONE.ln(), Rectangular::I * PI);
228 assert_eq!(Polar::NEG_I.ln(), Rectangular::I * -FRAC_PI_2);
229
230 assert_ulps_eq!(Polar::new(E, 0.0).ln(), Rectangular::ONE);
231 assert_ulps_eq!(Polar::new(2.0, 0.0).log2(), Rectangular::ONE);
232 assert_ulps_eq!(Polar::new(10.0, 0.0).log10(), Rectangular::ONE);
233 }
234
235 #[test]
236 fn powi() {
237 for z in random_samples::<Polar>() {
238 assert_eq!(z.powi(0), Polar::ONE);
239 assert_eq!(z.powi(1), z);
240 for n in random_samples::<i32>() {
241 assert_eq!(z.powi(n).abs, z.abs.powi(n));
242 assert_eq!(z.powi(n).arg, z.arg * n as FT);
243 }
244 }
245 for n in random_samples::<i32>() {
246 assert_eq!(Polar::ZERO.powi(n.abs()), Polar::ZERO);
247 assert_eq!(Polar::ONE.powi(n), Polar::ONE);
248 }
249 }
250
251 #[test]
252 fn powf() {
253 for z in random_samples::<Polar>() {
254 assert_eq!(z.powf(0.0), Polar::ONE);
255 assert_eq!(z.powf(1.0), z);
256 for n in random_samples::<i32>() {
257 let x = n as FT * 0.01;
258 assert_eq!(z.powf(x).abs, z.abs.powf(x));
259 assert_eq!(z.powf(x).arg, z.arg * x);
260 }
261 }
262 for n in random_samples::<i32>() {
263 let x = n as FT * 0.01;
264 assert_eq!(Polar::ZERO.powf(x.abs()), Polar::ZERO);
265 assert_eq!(Polar::ONE.powf(x), Polar::ONE);
266 }
267 }
268
269 #[test]
270 fn normalize() {
271 for z in random_samples::<Polar>() {
272 for n in uniform_samples::<i32>(-99, 99) {
273 let w = Polar::new(z.abs, z.arg + n as FT * TAU);
274 assert_ulps_eq!(z, w.normalize(), epsilon = 2000.0 * FT::EPSILON);
275
276 assert_ulps_eq!(
277 Polar::new(-z.abs, z.arg).normalize(),
278 Polar::new(z.abs, z.arg + PI).normalize(),
279 epsilon = 2000.0 * FT::EPSILON
280 );
281 }
282 }
283 }
284}