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 Complex<f64>

pub fn sqrt(&self) -> Complex<f64>

Return the square root of a complex number ( sqrt(z) )

pub fn pow(&self, w: &Complex<f64>) -> Complex<f64>

Return the complex number z raised to the power of a complex number w ( z^w )

pub fn powf(&self, x: f64) -> Complex<f64>

Return complex number z raised to the power of a real number x ( z^x )

pub fn exp(&self) -> Complex<f64>

Return the complex exponential of the complex number z ( exp(z) )

pub fn ln(&self) -> Complex<f64>

Return the complex logarithm of the complex number z ( ln(z) )

pub fn log(&self, b: Complex<f64>) -> Complex<f64>

Return the complex base-b logarithm of the complex number z ( log_b(z) )

pub fn polar(r: f64, theta: f64) -> Complex<f64>

Create a new complex number with magnitude r and phase angle theta

impl Complex<f64>

pub fn sin(&self) -> Complex<f64>

Return the sin of a complex number z ( sin(z) )

pub fn cos(&self) -> Complex<f64>

Return the cos of a complex number z ( cos(z) )

pub fn tan(&self) -> Complex<f64>

Return the tan of a complex number z ( tan(z) )

pub fn sec(&self) -> Complex<f64>

Return the sec of a complex number z ( sec(z) )

pub fn csc(&self) -> Complex<f64>

Return the csc of a complex number z ( csc(z) )

pub fn cot(&self) -> Complex<f64>

Return the cot of a complex number z ( cot(z) )

pub fn asin(&self) -> Complex<f64>

Return the inverse sin of a complex number z ( asin(z) )

pub fn acos(&self) -> Complex<f64>

Return the inverse cos of a complex number z ( acos(z) )

pub fn atan(&self) -> Complex<f64>

Return the inverse tan of a complex number z ( atan(z) )

pub fn asec(&self) -> Complex<f64>

Return the inverse sec of a complex number z ( asec(z) )

pub fn acsc(&self) -> Complex<f64>

Return the inverse csc of a complex number z ( acsc(z) )

pub fn acot(&self) -> Complex<f64>

Return the inverse cot of a complex number z ( acot(z) )

impl Complex<f64>

pub fn sinh(&self) -> Complex<f64>

Return the hyperbolic sine of a complex number z ( sinh(z) )

pub fn cosh(&self) -> Complex<f64>

Return the hyperbolic cosine of a complex number z ( cosh(z) )

pub fn tanh(&self) -> Complex<f64>

Return the hyperbolic tangent of a complex number z ( tanh(z) )

pub fn sech(&self) -> Complex<f64>

Return the hyperbolic secant of a complex number z ( sech(z) )

pub fn csch(&self) -> Complex<f64>

Return the hyperbolic cosecant of a complex number z ( csch(z) )

pub fn coth(&self) -> Complex<f64>

Return the hyperbolic cotangent of a complex number z ( coth(z) )

pub fn asinh(&self) -> Complex<f64>

Return the inverse hyperbolic sine of a complex number z ( asinh(z) )

pub fn acosh(&self) -> Complex<f64>

Return the inverse hyperbolic cosine of a complex number z ( acosh(z) )

pub fn atanh(&self) -> Complex<f64>

Return the inverse hyperbolic tangent of a complex number z ( atanh(z) )

pub fn asech(&self) -> Complex<f64>

Return the inverse hyperbolic secant of a complex number z ( asech(z) )

pub fn acsch(&self) -> Complex<f64>

Return the inverse hyperbolic cosecant of a complex number z ( acsch(z) )

pub fn acoth(&self) -> Complex<f64>

Return the inverse hyperbolic cotangent of a complex number z ( acoth(z) )

impl<T> Complex<T>

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

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

Examples found in repository

examples/complex_numbers.rs (line 12)

fn main() {
    println!("----- Complex numbers -----");

    // Create a new complex number
    let z = Cmplx::new( 1.0, -1.0 );
    println!( "  * z = {}", z );
    println!( "  * Re[z] = {}", z.real );
    println!( "  * Im[z] = {}", z.imag );

    // Take the conjugate
    let zbar = z.conj();
    println!("  * zbar = {}", zbar );

    // Modulus and arguement
    println!( "  * |z| = {}", z.abs() );
    println!( "  * arg(z) = {}", z.arg() );

    // Arithmetic
    let z1 = Complex::<f64>::new( 2.0, 1.0 );
    let z2 = z;
    println!( "  * z1 = {}", z1 );
    println!( "  * z2 = {}", z2 );
    println!( "  * z1 + z2 = {}", z1 + z2 );
    println!( "  * z1 - z2 = {}", z1 - z2 );
    println!( "  * z1 * z2 = {}", z1 * z2 );
    println!( "  * z1 / z2 = {}", z1 / z2 );
    let real: f64 = 2.0;
    println!( "  * z1 + 2 = {}", z1 + real );
    println!( "  * z1 - 2 = {}", z1 - real );
    println!( "  * z1 * 2 = {}", z1 * real );
    println!( "  * z1 / 2 = {}", z1 / real );
    println!( "  * z1 + i = {}", z1 + I );  
    println!( "--- FINISHED ---" );
}

examples/linear_systems.rs (line 26)

fn main() {
    println!( "------------------ Linear system ------------------" );
    println!( "  * Solving the linear system Ax = b, for x, where" );
    let mut a = Mat64::new( 3, 3, 0.0 );
    a[0][0] = 1.0; a[0][1] = 1.0; a[0][2] =   1.0;
    a[1][0] = 0.0; a[1][1] = 2.0; a[1][2] =   5.0;
    a[2][0] = 2.0; a[2][1] = 5.0; a[2][2] = - 1.0;
    println!( "  * A ={}", a );
    let b = Vec64::create( vec![ 6.0, -4.0, 27.0 ] ); 
    println!( "  * b^T ={}", b );
    let x = a.clone().solve_basic( b );
    println!( "  * gives the solution vector");
    println!( "  * x^T ={}", x );
    println!( "---------------------------------------------------" );
    println!( "  * Lets solve the complex linear system Cy = d where" );
    let mut c = Matrix::<Cmplx>::new( 2, 2, Cmplx::new( 1.0, 1.0 ) );
    c[0][1] = Cmplx::new( -1.0, 0.0 );
    c[1][0] = Cmplx::new( 1.0, -1.0 );
    println!( "  * C ={}", c );
    let mut d = Vector::<Cmplx>::new( 2, Cmplx::new( 0.0, 1.0 ) );
    d[1] = Cmplx::new( 1.0, 0.0 );
    println!( "  * d^T ={}", d );
    println!( "  * Using LU decomposition we find that ");
    let y = c.clone().solve_lu( d );
    println!( "  * y^T ={}", y );
    println!( "---------------------------------------------------" );
    println!( "  * We may also find the determinant of a matrix" );
    println!( "  * |A| = {}", a.clone().determinant() );
    println!( "  * |C| = {}", c.clone().determinant() ); 
    println!( "  * or the inverse of a matrix" );
    let inverse = a.clone().inverse();
    println!( "  * A^-1 =\n{}", inverse );
    println!( "  * C^-1 =\n{}", c.clone().inverse() );
    println!( "  * We can check this by multiplication" );
    println!( "  * I = A * A^-1 =\n{}", a * inverse );
    println!( "  * which is sufficiently accurate for our purposes.");
    println!( "-------------------- FINISHED ---------------------" );
}

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

pub fn conj(&self) -> Self

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

Examples found in repository

examples/complex_numbers.rs (line 18)

fn main() {
    println!("----- Complex numbers -----");

    // Create a new complex number
    let z = Cmplx::new( 1.0, -1.0 );
    println!( "  * z = {}", z );
    println!( "  * Re[z] = {}", z.real );
    println!( "  * Im[z] = {}", z.imag );

    // Take the conjugate
    let zbar = z.conj();
    println!("  * zbar = {}", zbar );

    // Modulus and arguement
    println!( "  * |z| = {}", z.abs() );
    println!( "  * arg(z) = {}", z.arg() );

    // Arithmetic
    let z1 = Complex::<f64>::new( 2.0, 1.0 );
    let z2 = z;
    println!( "  * z1 = {}", z1 );
    println!( "  * z2 = {}", z2 );
    println!( "  * z1 + z2 = {}", z1 + z2 );
    println!( "  * z1 - z2 = {}", z1 - z2 );
    println!( "  * z1 * z2 = {}", z1 * z2 );
    println!( "  * z1 / z2 = {}", z1 / z2 );
    let real: f64 = 2.0;
    println!( "  * z1 + 2 = {}", z1 + real );
    println!( "  * z1 - 2 = {}", z1 - real );
    println!( "  * z1 * 2 = {}", z1 * real );
    println!( "  * z1 / 2 = {}", z1 / real );
    println!( "  * z1 + i = {}", z1 + I );  
    println!( "--- FINISHED ---" );
}

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() ) )

Examples found in repository

examples/complex_numbers.rs (line 22)

fn main() {
    println!("----- Complex numbers -----");

    // Create a new complex number
    let z = Cmplx::new( 1.0, -1.0 );
    println!( "  * z = {}", z );
    println!( "  * Re[z] = {}", z.real );
    println!( "  * Im[z] = {}", z.imag );

    // Take the conjugate
    let zbar = z.conj();
    println!("  * zbar = {}", zbar );

    // Modulus and arguement
    println!( "  * |z| = {}", z.abs() );
    println!( "  * arg(z) = {}", z.arg() );

    // Arithmetic
    let z1 = Complex::<f64>::new( 2.0, 1.0 );
    let z2 = z;
    println!( "  * z1 = {}", z1 );
    println!( "  * z2 = {}", z2 );
    println!( "  * z1 + z2 = {}", z1 + z2 );
    println!( "  * z1 - z2 = {}", z1 - z2 );
    println!( "  * z1 * z2 = {}", z1 * z2 );
    println!( "  * z1 / z2 = {}", z1 / z2 );
    let real: f64 = 2.0;
    println!( "  * z1 + 2 = {}", z1 + real );
    println!( "  * z1 - 2 = {}", z1 - real );
    println!( "  * z1 * 2 = {}", z1 * real );
    println!( "  * z1 / 2 = {}", z1 / real );
    println!( "  * z1 + i = {}", z1 + I );  
    println!( "--- FINISHED ---" );
}

impl Complex<f64>

pub fn arg(&self) -> f64

Return the phase angle in radians

Examples found in repository

examples/complex_numbers.rs (line 23)

fn main() {
    println!("----- Complex numbers -----");

    // Create a new complex number
    let z = Cmplx::new( 1.0, -1.0 );
    println!( "  * z = {}", z );
    println!( "  * Re[z] = {}", z.real );
    println!( "  * Im[z] = {}", z.imag );

    // Take the conjugate
    let zbar = z.conj();
    println!("  * zbar = {}", zbar );

    // Modulus and arguement
    println!( "  * |z| = {}", z.abs() );
    println!( "  * arg(z) = {}", z.arg() );

    // Arithmetic
    let z1 = Complex::<f64>::new( 2.0, 1.0 );
    let z2 = z;
    println!( "  * z1 = {}", z1 );
    println!( "  * z2 = {}", z2 );
    println!( "  * z1 + z2 = {}", z1 + z2 );
    println!( "  * z1 - z2 = {}", z1 - z2 );
    println!( "  * z1 * z2 = {}", z1 * z2 );
    println!( "  * z1 / z2 = {}", z1 / z2 );
    let real: f64 = 2.0;
    println!( "  * z1 + 2 = {}", z1 + real );
    println!( "  * z1 - 2 = {}", z1 - real );
    println!( "  * z1 * 2 = {}", z1 * real );
    println!( "  * z1 / 2 = {}", z1 / real );
    println!( "  * z1 + i = {}", z1 + I );  
    println!( "--- FINISHED ---" );
}

Trait Implementations

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

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

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

type Output = Complex<T>

The resulting type after applying the + operator.

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

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

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

type Output = Complex<T>

The resulting type after applying the + operator.

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

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: Number> AddAssign for Complex<T>

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: Clone> Clone for Complex<T>

fn clone(&self) -> Self

Clone the complex number

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

Performs copy-assignment from source.

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

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

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

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

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

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

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

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

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

type Output = Complex<T>

The resulting type after applying the / operator.

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

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 )

type Output = Complex<T>

The resulting type after applying the / operator.

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

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> DivAssign for Complex<T>

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> Mul<T> for Complex<T>

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

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

type Output = Complex<T>

The resulting type after applying the * operator.

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

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

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

type Output = Complex<T>

The resulting type after applying the * operator.

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

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 + Number> MulAssign for Complex<T>

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 + Signed> Neg for Complex<T>

fn neg(self) -> Self::Output

Return the unary negation ( unary - )

• ( a + ib ) = -a - ib

type Output = Complex<T>

The resulting type after applying the - operator.

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

fn one() -> Self

Return the multiplicative identity z = 1 + 0i

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

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

Implement trait for equality

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: Clone + Number + PartialOrd> PartialOrd for Complex<T>

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

Implement trait for ordering

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 Signed for Complex<f64>

fn abs(&self) -> Self

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

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

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

type Output = Complex<T>

The resulting type after applying the - operator.

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

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

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

type Output = Complex<T>

The resulting type after applying the - operator.

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

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: Number> SubAssign for Complex<T>

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: Clone + Number> Zero for Complex<T>

fn zero() -> Self

Return the additive identity z = 0 + 0i

impl Copy for Complex<f64>

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