common-stdx 0.1.15

extension for the std lib, for things i commonly reuse
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

use num_traits::Num;
use num_traits::NumCast;
use std::ops::Div;

pub struct ComplexNum<T: Num + Copy> {
    real: T,
    imaginary: T,
}

pub struct ComplexPolar<T: Num + Copy> {
    radius: T,
    angle: T,
}

impl<T> ComplexNum<T>
where
    T: Copy + Clone + NumCast + Num,
{
    pub fn new(real: T, imaginary: T) -> Self {
        ComplexNum { real, imaginary }
    }

    pub fn conjugate(self) -> Self {
        ComplexNum::new(self.real, T::zero() - self.imaginary)
    }

    pub fn as_tuple(self) -> (T, T) {
        (self.real, self.imaginary)
    }

    pub fn from_polar(polar: ComplexPolar<T>) -> Option<Self> {
        let radius = polar.radius.to_f64()?;
        let angle = polar.angle.to_f64()?;

        let real_f64 = radius * angle.cos();
        let imaginary_f64 = radius * angle.sin();

        Some(ComplexNum {
            real: NumCast::from(real_f64)?,
            imaginary: NumCast::from(imaginary_f64)?,
        })
    }
    pub fn as_polar(&self) -> Option<ComplexPolar<T>> {
        let a = self.real.to_f64()?;
        let b = self.imaginary.to_f64()?;

        let radius = (a * a + b * b).sqrt();
        let angle = b.atan2(a);

        Some(ComplexPolar {
            radius: NumCast::from(radius)?,
            angle: NumCast::from(angle)?,
        })
    }
}

impl<T> std::ops::Add for ComplexNum<T>
where
    T: Num + Copy + Clone + NumCast,
{
    type Output = ComplexNum<T>;

    fn add(self, rhs: Self) -> Self::Output {
        ComplexNum::new(self.real + rhs.real, self.imaginary + rhs.imaginary)
    }
}

impl<T> std::ops::Sub for ComplexNum<T>
where
    T: Num + Copy + Clone + NumCast,
{
    type Output = ComplexNum<T>;

    fn sub(self, rhs: Self) -> Self::Output {
        ComplexNum::new(self.real - rhs.real, self.imaginary - rhs.imaginary)
    }
}

impl<T> std::ops::Mul for ComplexNum<T>
where
    T: Num + Copy + Clone + NumCast,
{
    type Output = ComplexNum<T>;

    fn mul(self, rhs: Self) -> Self::Output {
        // (a + bi)(c + di) = (ac - bd) + (ad + bc)i
        ComplexNum::new(
            self.real * rhs.real - self.imaginary * rhs.imaginary,
            self.real * rhs.imaginary + self.imaginary * rhs.real,
        )
    }
}

impl<T> std::ops::Div for ComplexNum<T>
where
    T: Num + Copy + Div<Output = T> + Clone + NumCast,
{
    type Output = ComplexNum<T>;

    fn div(self, rhs: Self) -> Self::Output {
        let denom = rhs.real * rhs.real + rhs.imaginary * rhs.imaginary;
        let numer = self * rhs.conjugate();

        ComplexNum::new(numer.real / denom, numer.imaginary / denom)
    }
}