complex_numbers 0.1.1

muehehehhehee
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

use std::fmt;
use std::fmt::Display;
use std::ops::{Add, Div, Mul, Sub};

/// `a` + `b` * `j`, where `j` is sqrt(-1)
#[derive(Clone, Copy, Debug)]
pub struct CompNum {
    pub a: f64,
    pub b: f64,
}
impl CompNum {
    pub fn from(a: f64, b: f64) -> Self {
        Self { a, b }
    }
    pub fn colapse(&self) -> Option<f64> {
        if self.b == 0.0 { Some(self.a) } else { None }
    }
}
impl Display for CompNum {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{} + {}j", self.a, self.b)
    }
}
impl Add<Self> for CompNum {
    type Output = Self;

    fn add(self, other: Self) -> Self {
        let a = self.a + other.a;
        let b = self.b + other.b;

        Self { a, b }
    }
}
impl Add<f64> for CompNum {
    type Output = Self;

    fn add(self, other: f64) -> Self {
        Self {
            a: self.a + other,
            b: self.b,
        }
    }
}
impl Sub<Self> for CompNum {
    type Output = Self;

    fn sub(self, other: Self) -> Self {
        let a = self.a - other.a;
        let b = self.b - other.b;

        Self { a, b }
    }
}
impl Sub<f64> for CompNum {
    type Output = Self;

    fn sub(self, other: f64) -> Self {
        let a = self.a - other;
        let b = self.b;

        Self { a, b }
    }
}
impl Mul<Self> for CompNum {
    type Output = Self;

    fn mul(self, other: Self) -> Self {
        let (a, b) = (self.a, self.b);
        let (c, d) = (other.a, other.b);

        let first = Self::from(a * c, a * d);
        let second = Self::from(-(b * d), b * c);
        let result = first + second;

        return result;
    }
}
impl Mul<f64> for CompNum {
    type Output = Self;

    fn mul(self, other: f64) -> Self {
        let (a, b) = (self.a * other, self.b * other);

        Self { a, b }
    }
}
impl Div<Self> for CompNum {
    type Output = Self;

    fn div(self, other: Self) -> Self {
        let (a, b) = (self.a, self.b);
        let (c, d) = (other.a, other.b);

        let temp_a = (a * c + b * d) / (c * c + d * d);
        let temp_b = (b * c - a * d) / (c * c + d * d);
        let result = Self::from(temp_a, temp_b);

        return result;
    }
}
impl Div<f64> for CompNum {
    type Output = Self;

    fn div(self, other: f64) -> Self {
        let (a, b) = (self.a / other, self.b / other);

        Self { a, b }
    }
}

// fn main() {
//     let num1 = CompNum::from(1.0, 2.0); // 1 + 2j
//     let num2 = CompNum::from(2.0, 3.0); // 3 + 4j
//
//     println!("{} / {} = {}", num1.clone(), 2.0, num1.clone() / 2.0);
// }