Struct Complex 

pub struct Complex<T> {
    pub re: T,
    pub im: T,
}

A complex number stored in rectangular form.

Fields

re: T

The real component.

im: T

The imaginary component.

Implementations

impl<T> Complex<T>

pub const fn new(re: T, im: T) -> Self

Creates a complex number from real and imaginary parts.

Examples found in repository

examples/basic_usage.rs (line 4)

fn main() {
    let value = Complex::new(3.0_f64, 4.0_f64);
    let mirrored = value.conjugate();
    let lifted = Complex::from(Imaginary::new(4.0_f64));
    let (magnitude, argument) = value.to_polar();

    assert_eq!(value + Complex::one(), Complex::new(4.0, 4.0));
    assert_eq!(mirrored, Complex::new(3.0, -4.0));
    assert_eq!(lifted, Complex::new(0.0, 4.0));
    assert!((magnitude - 5.0).abs() <= 1.0e-10);
    assert!((argument - value.argument()).abs() <= 1.0e-10);
}

pub const fn real(&self) -> &T

Returns the real component.

pub const fn imaginary(&self) -> &T

Returns the imaginary component.

impl<T> Complex<T>

where T: Default,

pub fn from_real(re: T) -> Self

Creates a real-only complex value.

pub fn from_imaginary(im: T) -> Self

Creates an imaginary-only complex value.

impl<T> Complex<T>

where T: Default + From<u8>,

pub fn zero() -> Self

Returns 0 + 0i.

pub fn one() -> Self

Returns 1 + 0i.

Examples found in repository

examples/basic_usage.rs (line 9)

fn main() {
    let value = Complex::new(3.0_f64, 4.0_f64);
    let mirrored = value.conjugate();
    let lifted = Complex::from(Imaginary::new(4.0_f64));
    let (magnitude, argument) = value.to_polar();

    assert_eq!(value + Complex::one(), Complex::new(4.0, 4.0));
    assert_eq!(mirrored, Complex::new(3.0, -4.0));
    assert_eq!(lifted, Complex::new(0.0, 4.0));
    assert!((magnitude - 5.0).abs() <= 1.0e-10);
    assert!((argument - value.argument()).abs() <= 1.0e-10);
}

pub fn i() -> Self

Returns 0 + 1i.

impl<T> Complex<T>

where T: Copy + Neg<Output = T>,

pub fn conjugate(&self) -> Self

Returns the complex conjugate.

Examples found in repository

examples/basic_usage.rs (line 5)

fn main() {
    let value = Complex::new(3.0_f64, 4.0_f64);
    let mirrored = value.conjugate();
    let lifted = Complex::from(Imaginary::new(4.0_f64));
    let (magnitude, argument) = value.to_polar();

    assert_eq!(value + Complex::one(), Complex::new(4.0, 4.0));
    assert_eq!(mirrored, Complex::new(3.0, -4.0));
    assert_eq!(lifted, Complex::new(0.0, 4.0));
    assert!((magnitude - 5.0).abs() <= 1.0e-10);
    assert!((argument - value.argument()).abs() <= 1.0e-10);
}

impl<T> Complex<T>

where T: Copy + Add<Output = T> + Mul<Output = T>,

pub fn magnitude_squared(&self) -> T

Returns the squared magnitude, re^2 + im^2.

impl Complex<f32>

pub fn magnitude(&self) -> f32

Returns the magnitude, sqrt(re^2 + im^2).

pub fn argument(&self) -> f32

Returns the argument in radians.

pub fn from_polar(magnitude: f32, argument: f32) -> Self

Builds a complex value from polar coordinates.

pub fn to_polar(&self) -> (f32, f32)

Returns (magnitude, argument) in polar form.

impl Complex<f64>

pub fn magnitude(&self) -> f64

Returns the magnitude, sqrt(re^2 + im^2).

pub fn argument(&self) -> f64

Returns the argument in radians.

Examples found in repository

examples/basic_usage.rs (line 13)

fn main() {
    let value = Complex::new(3.0_f64, 4.0_f64);
    let mirrored = value.conjugate();
    let lifted = Complex::from(Imaginary::new(4.0_f64));
    let (magnitude, argument) = value.to_polar();

    assert_eq!(value + Complex::one(), Complex::new(4.0, 4.0));
    assert_eq!(mirrored, Complex::new(3.0, -4.0));
    assert_eq!(lifted, Complex::new(0.0, 4.0));
    assert!((magnitude - 5.0).abs() <= 1.0e-10);
    assert!((argument - value.argument()).abs() <= 1.0e-10);
}

pub fn from_polar(magnitude: f64, argument: f64) -> Self

Builds a complex value from polar coordinates.

pub fn to_polar(&self) -> (f64, f64)

Returns (magnitude, argument) in polar form.

Examples found in repository

examples/basic_usage.rs (line 7)

fn main() {
    let value = Complex::new(3.0_f64, 4.0_f64);
    let mirrored = value.conjugate();
    let lifted = Complex::from(Imaginary::new(4.0_f64));
    let (magnitude, argument) = value.to_polar();

    assert_eq!(value + Complex::one(), Complex::new(4.0, 4.0));
    assert_eq!(mirrored, Complex::new(3.0, -4.0));
    assert_eq!(lifted, Complex::new(0.0, 4.0));
    assert!((magnitude - 5.0).abs() <= 1.0e-10);
    assert!((argument - value.argument()).abs() <= 1.0e-10);
}

Trait Implementations

impl<T> Add for Complex<T>

where T: Add<Output = T>,

type Output = Complex<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Clone> Clone for Complex<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Complex<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Complex<T>

fn default() -> Complex<T>

Returns the “default value” for a type.

impl<T> Display for Complex<T>

where T: Copy + Default + Display + Neg<Output = T> + PartialEq + PartialOrd,

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

Formats the value using the given formatter.

impl<T> Div for Complex<T>

where T: Copy + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Div<Output = T>,

type Output = Complex<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> From<Imaginary<T>> for Complex<T>

where T: Default,

fn from(value: Imaginary<T>) -> Self

Converts to this type from the input type.

impl<T> From<T> for Complex<T>

where T: Default,

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T> Mul for Complex<T>

where T: Copy + Add<Output = T> + Sub<Output = T> + Mul<Output = T>,

type Output = Complex<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Neg for Complex<T>

where T: Neg<Output = T>,

type Output = Complex<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: PartialEq> PartialEq for Complex<T>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T> Sub for Complex<T>

where T: Sub<Output = T>,

type Output = Complex<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Copy> Copy for Complex<T>

impl<T: Eq> Eq for Complex<T>

impl<T> StructuralPartialEq for Complex<T>