Struct ohsl::complex::Complex

pub struct Complex<T> {
    pub real: T,
    pub imag: T,
}

Fields

real: T

Real part of the complex number

imag: T

Imaginary part of the complex number

Implementations

impl<T> Complex<T>

pub const fn new(real: T, imag: T) -> Self

Create a new complex number ( z = x + iy )

impl<T: Clone + Signed> Complex<T>

pub fn conj(&self) -> Self

Return the complex conjugate ( z.conj() = x - iy )

impl<T: Clone + Number> Complex<T>

pub fn abs_sqr(&self) -> T

Return the absolute value squared ( |z|^2 = z * z.conj() )

impl Complex<f64>

pub fn abs(&self) -> f64

Return the absolute value ( |z| = sqrt( z * z.conj() ) )

impl Complex<f64>

pub fn arg(&self) -> f64

Return the phase angle in radians

Trait Implementations

impl<T: Clone + Number> Add<Complex<T>> for Complex<T>

type Output = Self

The resulting type after applying the + operator.

pub fn add(self, plus: Self) -> Self::Output

Add two complex numbers together ( binary + ) ( a + ib ) + ( c + id ) = ( a + c ) + i( b + d )

impl<T: Number> Add<T> for Complex<T>

type Output = Complex<T>

The resulting type after applying the + operator.

pub fn add(self, plus: T) -> Self::Output

Add a complex number to a real number ( a + ib ) + c = ( a + c ) + ib

impl<T: Number> AddAssign<Complex<T>> for Complex<T>

pub fn add_assign(&mut self, rhs: Self)

Add a complex number to a mutable complex variable and assign the result to that variable ( += )

impl<T: Number> AddAssign<T> for Complex<T>

pub fn add_assign(&mut self, rhs: T)

Add a real number to a mutable complex variable and assign the result to that variable ( += )

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

pub fn clone(&self) -> Self

Clone the complex number

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

Performs copy-assignment from source.

impl Copy for Complex<f64>

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

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

Format the output ( z = x + iy = ( x, y ) )

impl<T> Display for Complex<T> where
    T: Display, 

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

Format the output ( z = x + iy = ( x, y ) )

impl<T: Clone + Number> Div<Complex<T>> for Complex<T>

type Output = Self

The resulting type after applying the / operator.

pub fn div(self, divisor: Self) -> Self::Output

Divide one complex number by another ( binary / ) ( a + ib ) / ( c + id ) = [( ac + bd ) + i( bc - ad )] / ( c^2 + d^2 )

impl<T: Clone + Number> Div<T> for Complex<T>

type Output = Complex<T>

The resulting type after applying the / operator.

pub fn div(self, scalar: T) -> Self::Output

Divide a complex number by a real scalar ( a + ib ) / r = (a/r) + i(b/r)

impl<T: Clone + Number> DivAssign<Complex<T>> for Complex<T>

pub fn div_assign(&mut self, rhs: Self)

Divide a mutable complex variable by a complex number and assign the result to that variable ( *= )

impl<T: Clone + Number> DivAssign<T> for Complex<T>

pub fn div_assign(&mut self, rhs: T)

Divide a mutable complex variable by a real number and assign the result to that variable ( /= )

impl<T: Clone + Number> Mul<Complex<T>> for Complex<T>

type Output = Self

The resulting type after applying the * operator.

pub fn mul(self, times: Self) -> Self::Output

Multiply two complex numbers together ( binary * ) ( a + ib ) * ( c + id ) = ( ac - bd ) + i( ad + bc )

impl<T: Clone + Number> Mul<T> for Complex<T>

type Output = Complex<T>

The resulting type after applying the * operator.

pub fn mul(self, scalar: T) -> Self::Output

Multiply a complex number by a real scalar ( a + ib ) * r = (ar) + i(br)

impl<T: Clone + Number> MulAssign<Complex<T>> for Complex<T>

pub fn mul_assign(&mut self, rhs: Self)

Multipy a mutable complex variable by a complex number and assign the result to that variable ( *= )

impl<T: Clone + Number> MulAssign<T> for Complex<T>

pub fn mul_assign(&mut self, rhs: T)

Multiply a mutable complex variable by a real number and assign the result to that variable ( *= )

impl<T: Clone + Signed> Neg for Complex<T>

type Output = Self

The resulting type after applying the - operator.

pub fn neg(self) -> Self::Output

Return the unary negation ( unary - )

• ( a + ib ) = -a - ib

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

impl<T: Clone + Number> One for Complex<T>

pub fn one() -> Self

Return the multiplicative identity z = 1 + 0i

impl<T: Clone + Number> PartialEq<Complex<T>> for Complex<T>

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

Implement trait for equality

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: Clone + Number + PartialOrd> PartialOrd<Complex<T>> for Complex<T>

pub fn partial_cmp(&self, other: &Complex<T>) -> Option<Ordering>

Implement trait for ordering

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

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

#[must_use]pub fn le(&self, other: &Rhs) -> bool

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

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

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

#[must_use]pub 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 Signed for Complex<f64>

pub fn abs(&self) -> Self

impl<T: Clone + Number> Sub<Complex<T>> for Complex<T>

type Output = Self

The resulting type after applying the - operator.

pub fn sub(self, minus: Self) -> Self::Output

Subtract one complex number from another ( binary - ) ( a + ib ) - ( c + id ) = ( a - c ) + i( b - d )

impl<T: Number> Sub<T> for Complex<T>

type Output = Complex<T>

The resulting type after applying the - operator.

pub fn sub(self, minus: T) -> Self::Output

Subtract a real number from a complex number ( a + ib ) - c = ( a - c ) + ib

impl<T: Number> SubAssign<Complex<T>> for Complex<T>

pub fn sub_assign(&mut self, rhs: Self)

Subtract a complex number from a mutable complex variable and assign the result to that variable ( -= )

impl<T: Number> SubAssign<T> for Complex<T>

pub fn sub_assign(&mut self, rhs: T)

Subtract a real number from a mutable complex variable and assign the result to that variable ( += )

impl<T: Clone + Number> Zero for Complex<T>

pub fn zero() -> Self

Return the additive identity z = 0 + 0i