complexible 0.2.4

A minimal and user-friendly Rust library complex-number operations, bringing the joy of complex mathematics to Rustaceans everywhere!
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

use super::*;

/// Represents a complex number in Cartesian form.
///
/// # Fields
///
/// * `real` - The real part of the complex number.
/// * `imaginary` - The imaginary part of the complex number.
#[derive(Debug)]
pub struct CartesianComplexNumber {
    pub real: f64,
    pub imaginary: f64,
}
impl CartesianComplexNumber {
    /// Creates a new `CartesianComplexNumber` with the given real and imaginary parts.
    ///
    /// # Arguments
    ///
    /// * `real` - The real part of the complex number.
    /// * `imaginary` - The imaginary part of the complex number.
    ///
    /// # Example
    ///
    /// ```
    /// use complexible::complex_numbers::z::CartesianComplexNumber;
    ///
    /// let complex = CartesianComplexNumber::new(1.0, 2.0);
    /// assert_eq!(complex.real, 1.0);
    /// assert_eq!(complex.imaginary, 2.0);
    /// ```
    pub fn new(real: f64, imaginary: f64) -> CartesianComplexNumber {
        CartesianComplexNumber { real, imaginary }
    }
    /// Converts the `CartesianComplexNumber` to polar form.
    ///
    /// # Example
    ///
    /// ```
    /// use complexible::complex_numbers::z::CartesianComplexNumber;
    ///
    /// let complex = CartesianComplexNumber { real: 1.0, imaginary: 1.0 };
    /// let polar = complex.to_polar();
    /// assert_eq!(polar.magnitude, 1.4142135623730951);
    /// assert_eq!(polar.angle.d.value, 45.0);
    /// ```
    pub fn to_polar(&self) -> PolarComplexNumber {
        let magnitude = (self.real.powi(2) + self.imaginary.powi(2)).sqrt();
        let angle = Angle::from_radians(self.imaginary.atan2(self.real));
        PolarComplexNumber { magnitude, angle }
    }
}


/// Represents a complex number in polar form.
///
/// # Fields
///
/// * `magnitude` - The magnitude of the complex number.
/// * `angle` - The angle of the complex number, represented as an `Angle` struct.
#[derive(Debug)]
pub struct PolarComplexNumber {
    pub magnitude: f64,
    pub angle: Angle,
}
impl PolarComplexNumber {
    /// Creates a new `PolarComplexNumber` with the given magnitude and angle.
    ///
    /// # Arguments
    ///
    /// * `magnitude` - The magnitude of the complex number.
    /// * `angle` - The angle of the complex number, represented as an `Angle` struct.
    ///
    /// # Example
    ///
    /// ```
    /// use complexible::complex_numbers::{ * , z::*};
    ///
    /// let angle = Angle::from_degrees(45.0);
    /// let complex = PolarComplexNumber::new(1.0, angle);
    /// assert_eq!(complex.magnitude, 1.0);
    /// assert_eq!(complex.angle.d.value, 45.0);
    /// ```
    pub fn new(magnitude: f64, angle: Angle) -> PolarComplexNumber {
        PolarComplexNumber { magnitude, angle }
    }

    /// Converts the `PolarComplexNumber` to Cartesian form.
    ///
    /// # Example
    ///
    /// ```
    /// use complexible::complex_numbers::{ * , z::*};
    ///
    /// let angle = Angle::from_degrees(45.0);
    /// let polar = PolarComplexNumber { magnitude: 1.0, angle };
    /// let cartesian = polar.to_cartesian();
    /// assert_eq!(cartesian.real, 0.7071067811865476);
    /// assert_eq!(cartesian.imaginary, 0.7071067811865476    );
    /// ```
    pub fn to_cartesian(&self) -> CartesianComplexNumber {
        let r = self.angle.r.value;
        let real = self.magnitude * r.cos();
        let imaginary = self.magnitude * r.sin();
        CartesianComplexNumber { real, imaginary }
    }
}