Struct mixed_num::complex::Cartesian

#[repr(C)]
pub struct Cartesian<T> {
    pub re: T,
    pub im: T,
}

Fields

re: T

Real part.

im: T

Imaginary part.

Implementations

impl<T> Cartesian<T>

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

Trait Implementations

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> Add<&'_ Cartesian<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: &Cartesian<T>) -> Self

Performs the + operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> Add<&'_ Complex<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: &Complex<T>) -> Self

Performs the + operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> Add<&'_ mut Cartesian<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: &mut Cartesian<T>) -> Self

Performs the + operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> Add<&'_ mut Complex<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: &mut Complex<T>) -> Self

Performs the + operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> Add<Cartesian<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Cartesian<T>) -> Self

Performs the + operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> Add<Complex<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Complex<T>) -> Self

Performs the + operation.

impl<T1: MixedNum + MixedOps + MixedZero, T2: MixedNum + MixedOps + MixedNumConversion<T1>> Add<T1> for Cartesian<T2>

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

Example

use mixed_num::*;
use mixed_num::traits::*;
 
let mut c_num = Cartesian::new(1f32,2f32);
 
c_num = c_num+2f64;
assert_eq!{ c_num.to_string(), "3+2i" };

type Output = Self

The resulting type after applying the + operator.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> AddAssign<&'_ Cartesian<T>> for Cartesian<T>

fn add_assign(&mut self, rhs: &Cartesian<T>)

Performs the += operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> AddAssign<&'_ Complex<T>> for Cartesian<T>

fn add_assign(&mut self, rhs: &Complex<T>)

Performs the += operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> AddAssign<&'_ mut Cartesian<T>> for Cartesian<T>

fn add_assign(&mut self, rhs: &mut Cartesian<T>)

Performs the += operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> AddAssign<&'_ mut Complex<T>> for Cartesian<T>

fn add_assign(&mut self, rhs: &mut Complex<T>)

Performs the += operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> AddAssign<Cartesian<T>> for Cartesian<T>

fn add_assign(&mut self, rhs: Cartesian<T>)

Performs the += operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> AddAssign<Complex<T>> for Cartesian<T>

fn add_assign(&mut self, rhs: Complex<T>)

Performs the += operation.

impl<T1: MixedNum + MixedOps + MixedZero, T2: MixedOps + MixedNumConversion<T1>> AddAssign<T1> for Cartesian<T2>

fn add_assign(&mut self, rhs: T1)

Example

use mixed_num::*;
use mixed_num::traits::*;
 
let mut c_num = Cartesian::new(1f32,2f32);
 
c_num += 2f64;
assert_eq!{ c_num.to_string(), "3+2i" };

impl<T: MixedNum + MixedNumSigned + MixedAtan> Arg<T> for Cartesian<T>

fn arg(&self) -> T

Argument of the complex number.

fn ang(&self) -> T

Angle of the complex number.

impl<T: Clone> Clone for Cartesian<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: MixedComplex + NewFromCartesian<T2>, T2: MixedNum + MixedNumSigned> Conj<T> for Cartesian<T2>

fn conj(&self) -> T

Complex Conjugate of T.

Example

use mixed_num::*;
use mixed_num::traits::*;
 
let mut c_num = Cartesian::new(-2f32,-4f32);
 
c_num = c_num.conj();
assert_eq!{ c_num.to_string(), "-2+4i" };

impl<T: Debug> Debug for Cartesian<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Cartesian<T>

fn default() -> Cartesian<T>

Returns the “default value” for a type.

impl<T> Display for Cartesian<T> where
    T: Display + PartialOrd + Clone + MixedZero + MixedNum + Sub<Output = T>, 

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

Complex Conjugate of T.

Example

use mixed_num::*;
use mixed_num::traits::*;
 
let mut c_num = Cartesian::new(-2f32,4f32);
assert_eq!{ c_num.to_string(), "-2+4i" };
let mut c_num = Cartesian::new(2f32,-4f32);
assert_eq!{ c_num.to_string(), "2-4i" };

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedPowi> Div<&'_ Cartesian<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: &Cartesian<T>) -> Self

Performs the / operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedPowi> Div<&'_ Complex<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: &Complex<T>) -> Self

Performs the / operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedPowi> Div<&'_ mut Cartesian<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: &mut Cartesian<T>) -> Self

Performs the / operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedPowi> Div<&'_ mut Complex<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: &mut Complex<T>) -> Self

Performs the / operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedPowi> Div<Cartesian<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: Cartesian<T>) -> Self

Performs the / operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedPowi> Div<Complex<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: Complex<T>) -> Self

Performs the / operation.

impl<T1: MixedNumSigned + MixedOps + MixedZero, T2: MixedReal + MixedOps + MixedNumConversion<T1>> Div<T1> for Cartesian<T2>

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

Example

use mixed_num::*;
use mixed_num::traits::*;
 
let mut c_num = Cartesian::new(-2f32,4f32);
 
c_num = c_num/2f64;
assert_eq!{ c_num.to_string(), "-1+2i" };

type Output = Self

The resulting type after applying the / operator.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero + MixedPowi> DivAssign<&'_ Cartesian<T>> for Cartesian<T>

fn div_assign(&mut self, rhs: &Cartesian<T>)

Performs the /= operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero + MixedPowi> DivAssign<&'_ Complex<T>> for Cartesian<T>

fn div_assign(&mut self, rhs: &Complex<T>)

Performs the /= operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero + MixedPowi> DivAssign<&'_ mut Cartesian<T>> for Cartesian<T>

fn div_assign(&mut self, rhs: &mut Cartesian<T>)

Performs the /= operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero + MixedPowi> DivAssign<&'_ mut Complex<T>> for Cartesian<T>

fn div_assign(&mut self, rhs: &mut Complex<T>)

Performs the /= operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero + MixedPowi> DivAssign<Cartesian<T>> for Cartesian<T>

fn div_assign(&mut self, rhs: Cartesian<T>)

Performs the /= operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero + MixedPowi> DivAssign<Complex<T>> for Cartesian<T>

fn div_assign(&mut self, rhs: Complex<T>)

Performs the /= operation.

impl<T1: MixedNumSigned + MixedOps + MixedZero, T2: MixedReal + MixedOps + MixedNumConversion<T1>> DivAssign<T1> for Cartesian<T2>

fn div_assign(&mut self, rhs: T1)

Example

use mixed_num::*;
use mixed_num::traits::*;
 
let mut c_num = Cartesian::new(-2f32,4f32);
 
c_num /= 2f64;
assert_eq!{ c_num.to_string(), "-1+2i" };

impl<T: MixedNum + MixedNumSigned + MixedSqrt + MixedPowi + MixedOps> Mag<T> for Cartesian<T>

fn mag(&self) -> T

Magnitude of the complex number.

fn abs(&self) -> T

Magnitude of the complex number.

impl<T: MixedNum + MixedNumSigned + MixedSqrt + MixedPowi + MixedOps + MixedZero> MixedAbs for Cartesian<T>

fn mixed_abs(&self) -> Self

Absolute value.

impl<T: MixedNum + MixedZero> MixedComplexConversion<T> for Cartesian<T>

fn mixed_to_complex(number: T) -> Self

Type cast from real number T to Complex.

impl<T: MixedNum + MixedNumConversion<T2> + MixedZero, T2: MixedNum> MixedNumConversion<T2> for Cartesian<T>

fn mixed_from_num(number: T2) -> Self

Generic type cast from numeric type T.

fn mixed_to_num(&self) -> T2

Generic type cast to numeric type T.

impl<T: MixedNum + MixedZero + MixedOne> MixedOne for Cartesian<T>

fn mixed_one() -> Self

Return the zero value of type Self.

impl<T: MixedNum + MixedZero> MixedZero for Cartesian<T>

fn mixed_zero() -> Self

Return the zero value of type Self.

impl<T: MixedNum + MixedNumSigned + MixedOps> Mul<&'_ Cartesian<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: &Cartesian<T>) -> Cartesian<T>

Performs the * operation.

impl<T: MixedNum + MixedNumSigned + MixedTrigonometry + MixedWrapPhase + MixedOps> Mul<&'_ Polar<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: &Polar<T>) -> Self

Performs the * operation.

impl<T: MixedNum + MixedNumSigned + MixedOps> Mul<&'_ mut Cartesian<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: &mut Cartesian<T>) -> Cartesian<T>

Performs the * operation.

impl<T: MixedNum + MixedNumSigned + MixedTrigonometry + MixedWrapPhase + MixedOps> Mul<&'_ mut Polar<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: &mut Polar<T>) -> Self

Performs the * operation.

impl<T: MixedNum + MixedNumSigned + MixedOps> Mul<Cartesian<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: MixedNum + MixedNumSigned + MixedSqrt + MixedOps + MixedAbs + MixedPowi + MixedAtan + ToPolar<T>> Mul<Cartesian<T>> for Polar<T>

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: Cartesian<T>) -> Self

Performs the * operation.

impl<T: MixedNum + MixedNumSigned + MixedTrigonometry + MixedWrapPhase + MixedOps> Mul<Polar<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: Polar<T>) -> Self

Performs the * operation.

impl<T1: MixedNum + MixedOps, T2: MixedNum + MixedOps + MixedNumConversion<T1>> Mul<T1> for Cartesian<T2>

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

Example

use mixed_num::*;
use mixed_num::traits::*;
 
let mut c_num = Cartesian::new(1f32,2f32);
 
c_num = c_num*2f64;
assert_eq!{ c_num.to_string(), "2+4i" };

type Output = Self

The resulting type after applying the * operator.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedTrigonometry + MixedWrapPhase> MulAssign<&'_ Polar<T>> for Cartesian<T>

fn mul_assign(&mut self, rhs: &Polar<T>)

Performs the *= operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedTrigonometry + MixedWrapPhase> MulAssign<&'_ mut Polar<T>> for Cartesian<T>

fn mul_assign(&mut self, rhs: &mut Polar<T>)

Performs the *= operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedTrigonometry + MixedWrapPhase> MulAssign<Polar<T>> for Cartesian<T>

fn mul_assign(&mut self, rhs: Polar<T>)

Performs the *= operation.

impl<T: MixedNum + MixedNumSigned> NewFromCartesian<T> for Cartesian<T>

fn new_from_cartesian(re: T, im: T) -> Self

Type cast from real number T to Complex.

impl<T: MixedNum + MixedNumSigned + MixedWrapPhase + MixedTrigonometry + MixedOps> NewFromPolar<T> for Cartesian<T>

fn new_from_polar(mag: T, ang: T) -> Self

Create a complex number from polar coordinates.

impl<T: PartialEq> PartialEq<Cartesian<T>> for Cartesian<T>

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

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

fn ne(&self, other: &Cartesian<T>) -> bool

This method tests for !=.

impl<T: PartialOrd> PartialOrd<Cartesian<T>> for Cartesian<T>

fn partial_cmp(&self, other: &Cartesian<T>) -> 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: MixedNum + MixedNumSigned + MixedOps + MixedZero> Sub<&'_ Cartesian<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: &Cartesian<T>) -> Self

Performs the - operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> Sub<&'_ Complex<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: &Complex<T>) -> Self

Performs the - operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> Sub<&'_ mut Cartesian<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: &mut Cartesian<T>) -> Self

Performs the - operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> Sub<&'_ mut Complex<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: &mut Complex<T>) -> Self

Performs the - operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> Sub<Cartesian<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: Cartesian<T>) -> Self

Performs the - operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> Sub<Complex<T>> for Cartesian<T>

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: Complex<T>) -> Self

Performs the - operation.

impl<T1: MixedNum + MixedOps, T2: MixedOps + MixedNumConversion<T1>> Sub<T1> for Cartesian<T2>

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

Example

use mixed_num::*;
use mixed_num::traits::*;
 
let mut c_num = Cartesian::new(1f32,2f32);
 
c_num = c_num-2f64;
assert_eq!{ c_num.to_string(), "-1+2i" };

type Output = Self

The resulting type after applying the - operator.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> SubAssign<&'_ Cartesian<T>> for Cartesian<T>

fn sub_assign(&mut self, rhs: &Cartesian<T>)

Performs the -= operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> SubAssign<&'_ Complex<T>> for Cartesian<T>

fn sub_assign(&mut self, rhs: &Complex<T>)

Performs the -= operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> SubAssign<&'_ mut Cartesian<T>> for Cartesian<T>

fn sub_assign(&mut self, rhs: &mut Cartesian<T>)

Performs the -= operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> SubAssign<&'_ mut Complex<T>> for Cartesian<T>

fn sub_assign(&mut self, rhs: &mut Complex<T>)

Performs the -= operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> SubAssign<Cartesian<T>> for Cartesian<T>

fn sub_assign(&mut self, rhs: Cartesian<T>)

Performs the -= operation.

impl<T: MixedNum + MixedNumSigned + MixedOps + MixedZero> SubAssign<Complex<T>> for Cartesian<T>

fn sub_assign(&mut self, rhs: Complex<T>)

Performs the -= operation.

impl<T1: MixedNum + MixedOps, T2: MixedOps + MixedNumConversion<T1>> SubAssign<T1> for Cartesian<T2>

fn sub_assign(&mut self, rhs: T1)

Example

use mixed_num::*;
use mixed_num::traits::*;
 
let mut c_num = Cartesian::new(1f32,2f32);
 
c_num = c_num-2f64;
assert_eq!{ c_num.to_string(), "-1+2i" };

impl<T: MixedNum + MixedNumSigned> ToCartesian<T> for Cartesian<T>

fn to_cartesian(&self) -> Cartesian<T>

Converison to Complex.

impl<T: MixedNum + MixedNumSigned + MixedSqrt + MixedOps + MixedAbs + MixedPowi + MixedAtan> ToPolar<T> for Cartesian<T>

fn to_polar(&self) -> Polar<T>

Complex to Polar.

impl<T: Copy> Copy for Cartesian<T>

impl<T: Eq> Eq for Cartesian<T>

impl<T: MixedNum + MixedNumSigned> MixedComplex for Cartesian<T>

impl<T> StructuralEq for Cartesian<T>

impl<T> StructuralPartialEq for Cartesian<T>