Struct lib_rapid::math::complex::ComplexNumber

pub struct ComplexNumber<T> {
    pub real: T,
    pub complex: T,
}

The generic Complex number type.

Examples

use lib_rapid::math::complex::ComplexNumber;
use lib_rapid::math::general::delta;
 
let mut c1 = ComplexNumber::new(4.0, 2.8);
let mut c2 = ComplexNumber::new(2.0, 3.8);
let mut complex = c1.clone();
let mut expected;
 
// Addition
expected = ComplexNumber::new(6.0, 6.6);
assert_eq!(c1 + c2, expected);
complex += c2;
assert_eq!(complex, expected);
 
// Subtraction
expected = ComplexNumber::new(-2.0, 1.0);
complex = c2.clone();
complex -= c1;
assert_eq!(c2 - c1, expected);
assert_eq!(complex, expected);
 
// Multiplication
expected = ComplexNumber::new(-2.64, 20.8);
complex = c1.clone();
complex *= c2;
assert!( delta( (c1 * c2).real,    expected.real    ) < 1e-10);
assert!( delta( (c1 * c2).complex, expected.complex ) < 1e-10);
assert!( delta( complex.real,      expected.real    ) < 1e-10);
assert!( delta( complex.complex,   expected.complex ) < 1e-10);
 
// Multiplication
c1 = ComplexNumber::new(2.0, 2.0);
c2 = ComplexNumber::new(4.0, 3.0);
expected = ComplexNumber::new(0.56, 0.08);
complex = c1.clone();
complex /= c2;
assert!( delta( (c1 / c2).real,    expected.real    ) < 1e-10);
assert!( delta( (c1 / c2).complex, expected.complex ) < 1e-10);
assert!( delta( complex.real,      expected.real    ) < 1e-10);
assert!( delta( complex.complex,   expected.complex ) < 1e-10);
 
// Convert from real to complex
assert_eq!(ComplexNumber::from(5.0), ComplexNumber::new(5.0, 0.0));

Fields

real: T

complex: T

Implementations

impl<T: Neg<Output = T> + Div<Output = T> + Mul<Output = T> + Sub<Output = T> + Add<Output = T> + Copy + NumTools<T> + From<u8>> ComplexNumber<T>

where f64: From<T>,

pub fn new(real: T, complex: T) -> ComplexNumber<T>

Create a new Complex number of the form a + bi with a,b ∈ ℝ.

Arguments

• real: T - The real part of a complex number.
• complex: T - The real part of a complex number.

Returns

A ComplexNumber<T>.

Examples

use lib_rapid::math::complex::ComplexNumber;
 
let c = ComplexNumber::new(2, -4);
assert_eq!(c.to_string(), "2 - 4i".to_owned());

pub fn new_unitc() -> ComplexNumber<T>

Create a new Complex number with the values 0 + 1i.

Returns

A ComplexNumber<T>.

Examples

use lib_rapid::math::complex::ComplexNumber;
 
let c = ComplexNumber::new(0, 1);
assert_eq!(c, ComplexNumber::new_unitc());

pub fn recip(&self) -> ComplexNumber<T>

Calculate the reciprocal of a complex number.

Returns

A ComplexNumber<T>.

Examples

use lib_rapid::math::complex::ComplexNumber;
 
let c = ComplexNumber::new(2.0, -4.0);
assert_eq!(c.recip(), ComplexNumber::new(0.1, 0.2));

pub fn complex_conjugate(&self) -> ComplexNumber<T>

Calculate the complex conjugage of a complex number.

Returns

A ComplexNumber<T>.

Examples

use lib_rapid::math::complex::ComplexNumber;
 
let c = ComplexNumber::new(2, -4);
assert_eq!(c.complex_conjugate(), ComplexNumber::new(2, 4));

pub fn abs_f64(&self) -> f64

Calculate the absolute value of a complex number.

Returns

A f64.

Examples

use lib_rapid::math::complex::ComplexNumber;
use lib_rapid::math::constants::SQRT5;
 
let c = ComplexNumber::new(2, -4);
assert!((2.0 * SQRT5 - c.abs_f64()).abs() < 1e-10);

pub fn abs_f32(&self) -> f32

Calculate the absolute value of a complex number.

Returns

A f32.

Examples

use lib_rapid::math::complex::ComplexNumber;
use lib_rapid::math::constants::SQRT5;
 
let c = ComplexNumber::new(2, -4);
assert!((2.0 * SQRT5 as f32 - c.abs_f32()).abs() < 1e-10);

pub fn powi(&self, pow: isize) -> ComplexNumber<T>

Raise self to a whole number power pow.

Arguments

• pow: isize - the power.

Returns

A ComplexNumber<T>.

Examples

use lib_rapid::math::complex::ComplexNumber;
 
let c = ComplexNumber::new(2, -4);
assert_eq!(c.powi(2), ComplexNumber::new(-12, -16));

pub fn exp_f64(&self) -> ComplexNumber<f64>

Raise e to a imaginary number self.

Returns

A ComplexNumber<f64>.

Examples

use lib_rapid::math::complex::ComplexNumber;
use lib_rapid::math::constants::{PI, E};
 
let c = ComplexNumber::new(PI, PI);
assert!((c.exp_f64().real + E.powf(PI)).abs() < 1e-10);

Trait Implementations

impl<T: Add<Output = T>> Add for ComplexNumber<T>

type Output = ComplexNumber<T>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<T: Add<Output = T> + Copy> AddAssign for ComplexNumber<T>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T: Clone> Clone for ComplexNumber<T>

fn clone(&self) -> ComplexNumber<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for ComplexNumber<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Display + Neg<Output = T> + From<u8> + PartialOrd + Copy> Display for ComplexNumber<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Mul<Output = T> + Sub<Output = T> + Add<Output = T> + Div<Output = T> + NumTools<T> + Copy> Div for ComplexNumber<T>

type Output = ComplexNumber<T>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<T: Mul<Output = T> + Sub<Output = T> + Add<Output = T> + Div<Output = T> + NumTools<T> + Copy> DivAssign for ComplexNumber<T>

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<T: From<u8>> From<T> for ComplexNumber<T>

fn from(_a: T) -> Self

Converts to this type from the input type.

impl<T: Mul<Output = T> + Sub<Output = T> + Add<Output = T> + Copy> Mul for ComplexNumber<T>

type Output = ComplexNumber<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<T: Mul<Output = T> + Sub<Output = T> + Add<Output = T> + Copy> MulAssign for ComplexNumber<T>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<T: PartialEq> PartialEq for ComplexNumber<T>

fn eq(&self, other: &ComplexNumber<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialEq + PartialOrd> PartialOrd for ComplexNumber<T>

This PartialOrd implementation uses Lexicographical ordering. This means:

• Ordered by real part if a₁ ≠ a₂.
• Ordered by imaginary part if a₁ = a₂.

use lib_rapid::math::complex::ComplexNumber;
 
assert!(ComplexNumber::new(2, 3) < ComplexNumber::new(3, 4));
assert!(ComplexNumber::new(2, 1) > ComplexNumber::new(2, 0));

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Sub<Output = T>> Sub for ComplexNumber<T>

type Output = ComplexNumber<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<T: Sub<Output = T> + Copy> SubAssign for ComplexNumber<T>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<T: Copy> Copy for ComplexNumber<T>

impl<T: Eq> Eq for ComplexNumber<T>

impl<T> StructuralEq for ComplexNumber<T>

impl<T> StructuralPartialEq for ComplexNumber<T>