Struct Cartesian

Source

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

Expand description

Cartesian complex number.

Fields§

§re: T

Real part.

§im: T

Imaginary part.

Implementations§

Source §

impl<T> Cartesian<T>

Source §

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

Performs the + operation. Read more

Source §

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

Source §

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" };

Source §

type Output = Cartesian<T2>

The resulting type after applying the + operator.

Source §

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

Source §

type Output = Cartesian<T>

The resulting type after applying the + operator.

Source §

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" };

Source §

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

Source §

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

Performs the += operation. Read more

Source §

Returns a duplicate of the value. Read more

1.0.0 · Source§

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

Performs copy-assignment from source. Read more

Source §

§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" };

Source §

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

Source §

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" };

Source §

type Output = Cartesian<T2>

The resulting type after applying the / operator.

Source §

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

Source §

type Output = Cartesian<T>

The resulting type after applying the / operator.

Source §

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" };

Source §

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

Source §

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

Performs the /= operation. Read more

Source §

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

Source §

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

§Example

use mixed_num::*;
use mixed_num::traits::*;
 
let mut c_num = Cartesian::new(2e9f32,-4f32);
assert_eq!{ format!("{:e}", c_num), "2e9-4e0i" };

Source §

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

Source §

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

Formats the value using the given formatter. Read more

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

Source §

fn mixed_to_complex(number: T) -> Self

Type cast from real number T to Complex.

Source §

impl<T: MixedReal + MixedNumSigned + MixedSin + MixedExp + MulAssign> MixedExp for Cartesian<T>

Source §

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

§Example

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

Extracts real part of self, including type cast to the target type.

§Example

use mixed_num::*;
use mixed_num::traits::*;

let num = Cartesian::new(1f32,0f32);
 
let real_num:f64 = f64::mixed_from_num(num);
 
assert_eq!{ real_num, 1f64 };

Source §

fn mixed_to_num(&self) -> Cartesian<f32>

Casting real number to a complex, including type cast of T1 to T2 (Cartesian).

§Example

use mixed_num::*;
use mixed_num::traits::*;
 
// Notice the support cor type cast as well as real/complex conversion. 
let num: Cartesian<f64> = 2f32.mixed_to_num();
 
assert_eq!{ num.to_string(), "2+0i" };

Extracts real part of self, including type cast to the target type.

§Example

use mixed_num::*;
use mixed_num::traits::*;

let num = Cartesian::new(1f32,0f32);
 
let real_num:f64 = f64::mixed_from_num(num);
 
assert_eq!{ real_num, 1f64 };

Source §

fn mixed_to_num(&self) -> Cartesian<f64>

Casting real number to a complex, including type cast of T1 to T2 (Cartesian).

§Example

use mixed_num::*;
use mixed_num::traits::*;
 
// Notice the support cor type cast as well as real/complex conversion. 
let num: Cartesian<f64> = 2f32.mixed_to_num();
 
assert_eq!{ num.to_string(), "2+0i" };

Extracts real part of self, including type cast to the target type.

§Example

use mixed_num::*;
use mixed_num::traits::*;

let num = Cartesian::new(1f32,0f32);
 
let real_num:f64 = f64::mixed_from_num(num);
 
assert_eq!{ real_num, 1f64 };

Source §

fn mixed_to_num(&self) -> Cartesian<i128>

Casting real number to a complex, including type cast of T1 to T2 (Cartesian).

§Example

use mixed_num::*;
use mixed_num::traits::*;
 
// Notice the support cor type cast as well as real/complex conversion. 
let num: Cartesian<f64> = 2f32.mixed_to_num();
 
assert_eq!{ num.to_string(), "2+0i" };

Extracts real part of self, including type cast to the target type.

§Example

use mixed_num::*;
use mixed_num::traits::*;

let num = Cartesian::new(1f32,0f32);
 
let real_num:f64 = f64::mixed_from_num(num);
 
assert_eq!{ real_num, 1f64 };

Source §

fn mixed_to_num(&self) -> Cartesian<i16>

Casting real number to a complex, including type cast of T1 to T2 (Cartesian).

§Example

use mixed_num::*;
use mixed_num::traits::*;
 
// Notice the support cor type cast as well as real/complex conversion. 
let num: Cartesian<f64> = 2f32.mixed_to_num();
 
assert_eq!{ num.to_string(), "2+0i" };

Extracts real part of self, including type cast to the target type.

§Example

use mixed_num::*;
use mixed_num::traits::*;

let num = Cartesian::new(1f32,0f32);
 
let real_num:f64 = f64::mixed_from_num(num);
 
assert_eq!{ real_num, 1f64 };

Source §

fn mixed_to_num(&self) -> Cartesian<i32>

Casting real number to a complex, including type cast of T1 to T2 (Cartesian).

§Example

use mixed_num::*;
use mixed_num::traits::*;
 
// Notice the support cor type cast as well as real/complex conversion. 
let num: Cartesian<f64> = 2f32.mixed_to_num();
 
assert_eq!{ num.to_string(), "2+0i" };

Extracts real part of self, including type cast to the target type.

§Example

use mixed_num::*;
use mixed_num::traits::*;

let num = Cartesian::new(1f32,0f32);
 
let real_num:f64 = f64::mixed_from_num(num);
 
assert_eq!{ real_num, 1f64 };

Source §

fn mixed_to_num(&self) -> Cartesian<i64>

Casting real number to a complex, including type cast of T1 to T2 (Cartesian).

§Example

use mixed_num::*;
use mixed_num::traits::*;
 
// Notice the support cor type cast as well as real/complex conversion. 
let num: Cartesian<f64> = 2f32.mixed_to_num();
 
assert_eq!{ num.to_string(), "2+0i" };

Extracts real part of self, including type cast to the target type.

§Example

use mixed_num::*;
use mixed_num::traits::*;

let num = Cartesian::new(1f32,0f32);
 
let real_num:f64 = f64::mixed_from_num(num);
 
assert_eq!{ real_num, 1f64 };

Source §

fn mixed_to_num(&self) -> Cartesian<i8>

Casting real number to a complex, including type cast of T1 to T2 (Cartesian).

§Example

use mixed_num::*;
use mixed_num::traits::*;
 
// Notice the support cor type cast as well as real/complex conversion. 
let num: Cartesian<f64> = 2f32.mixed_to_num();
 
assert_eq!{ num.to_string(), "2+0i" };

Extracts real part of self, including type cast to the target type.

§Example

use mixed_num::*;
use mixed_num::traits::*;

let num = Cartesian::new(1f32,0f32);
 
let real_num:f64 = f64::mixed_from_num(num);
 
assert_eq!{ real_num, 1f64 };

Source §

fn mixed_to_num(&self) -> Cartesian<isize>

Casting real number to a complex, including type cast of T1 to T2 (Cartesian).

§Example

use mixed_num::*;
use mixed_num::traits::*;
 
// Notice the support cor type cast as well as real/complex conversion. 
let num: Cartesian<f64> = 2f32.mixed_to_num();
 
assert_eq!{ num.to_string(), "2+0i" };

Extracts real part of self, including type cast to the target type.

§Example

use mixed_num::*;
use mixed_num::traits::*;

let num = Cartesian::new(1f32,0f32);
 
let real_num:f64 = f64::mixed_from_num(num);
 
assert_eq!{ real_num, 1f64 };

Source §

fn mixed_to_num(&self) -> Cartesian<u128>

Casting real number to a complex, including type cast of T1 to T2 (Cartesian).

§Example

use mixed_num::*;
use mixed_num::traits::*;
 
// Notice the support cor type cast as well as real/complex conversion. 
let num: Cartesian<f64> = 2f32.mixed_to_num();
 
assert_eq!{ num.to_string(), "2+0i" };

Extracts real part of self, including type cast to the target type.

§Example

use mixed_num::*;
use mixed_num::traits::*;

let num = Cartesian::new(1f32,0f32);
 
let real_num:f64 = f64::mixed_from_num(num);
 
assert_eq!{ real_num, 1f64 };

Source §

fn mixed_to_num(&self) -> Cartesian<u16>

Casting real number to a complex, including type cast of T1 to T2 (Cartesian).

§Example

use mixed_num::*;
use mixed_num::traits::*;
 
// Notice the support cor type cast as well as real/complex conversion. 
let num: Cartesian<f64> = 2f32.mixed_to_num();
 
assert_eq!{ num.to_string(), "2+0i" };

Extracts real part of self, including type cast to the target type.

§Example

use mixed_num::*;
use mixed_num::traits::*;

let num = Cartesian::new(1f32,0f32);
 
let real_num:f64 = f64::mixed_from_num(num);
 
assert_eq!{ real_num, 1f64 };

Source §

fn mixed_to_num(&self) -> Cartesian<u32>

Casting real number to a complex, including type cast of T1 to T2 (Cartesian).

§Example

use mixed_num::*;
use mixed_num::traits::*;
 
// Notice the support cor type cast as well as real/complex conversion. 
let num: Cartesian<f64> = 2f32.mixed_to_num();
 
assert_eq!{ num.to_string(), "2+0i" };

Extracts real part of self, including type cast to the target type.

§Example

use mixed_num::*;
use mixed_num::traits::*;

let num = Cartesian::new(1f32,0f32);
 
let real_num:f64 = f64::mixed_from_num(num);
 
assert_eq!{ real_num, 1f64 };

Source §

fn mixed_to_num(&self) -> Cartesian<u64>

Casting real number to a complex, including type cast of T1 to T2 (Cartesian).

§Example

use mixed_num::*;
use mixed_num::traits::*;
 
// Notice the support cor type cast as well as real/complex conversion. 
let num: Cartesian<f64> = 2f32.mixed_to_num();
 
assert_eq!{ num.to_string(), "2+0i" };

Extracts real part of self, including type cast to the target type.

§Example

use mixed_num::*;
use mixed_num::traits::*;

let num = Cartesian::new(1f32,0f32);
 
let real_num:f64 = f64::mixed_from_num(num);
 
assert_eq!{ real_num, 1f64 };

Source §

fn mixed_to_num(&self) -> Cartesian<u8>

Casting real number to a complex, including type cast of T1 to T2 (Cartesian).

§Example

use mixed_num::*;
use mixed_num::traits::*;
 
// Notice the support cor type cast as well as real/complex conversion. 
let num: Cartesian<f64> = 2f32.mixed_to_num();
 
assert_eq!{ num.to_string(), "2+0i" };

Extracts real part of self, including type cast to the target type.

§Example

use mixed_num::*;
use mixed_num::traits::*;

let num = Cartesian::new(1f32,0f32);
 
let real_num:f64 = f64::mixed_from_num(num);
 
assert_eq!{ real_num, 1f64 };

Source §

fn mixed_to_num(&self) -> Cartesian<usize>

Casting real number to a complex, including type cast of T1 to T2 (Cartesian).

§Example

use mixed_num::*;
use mixed_num::traits::*;
 
// Notice the support cor type cast as well as real/complex conversion. 
let num: Cartesian<f64> = 2f32.mixed_to_num();
 
assert_eq!{ num.to_string(), "2+0i" };

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" };
 
let mut c_num = Cartesian::new(1f32,2f32);
c_num = c_num*2f32;
assert_eq!{ c_num.to_string(), "2+4i" };

Source §

type Output = Cartesian<T2>

The resulting type after applying the * operator.

Source §

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

Source §

type Output = Cartesian<T>

The resulting type after applying the * operator.

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

Source §

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

Source §

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

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

1.0.0 · Source§

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

Tests less than (for self and other) and is used by the < operator. Read more

1.0.0 · Source§

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

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

Source §

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" };

Source §

type Output = Cartesian<T2>

The resulting type after applying the - operator.

Source §

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

Source §

type Output = Cartesian<T>

The resulting type after applying the - operator.

Source §

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" };

use mixed_num::*;
use mixed_num::traits::*;
 
let mut c_num = Cartesian::new(2e9f32,-4f32);
assert_eq!{ format!("{:E}", c_num), "2E9-4E0i" };

Source §

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

Source §

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

Formats the value using the given formatter. Read more

Source §

impl<T> StructuralPartialEq for Cartesian<T>

impl<T, U> Into for T
where U: From<T>,

Source §

fn into(self) -> U

Calls U::from(self).

impl<T, U> TryInto for T
where U: TryFrom<T>,

Source §

type Error = >::Error

The type returned in the event of a conversion error.

Fields§

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 = Cartesian<T>

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

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

type Output = Cartesian<T>

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

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

type Output = Cartesian<T>

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

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

type Output = Cartesian<T>

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

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

type Output = Cartesian<T>

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

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

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

§Example

type Output = Cartesian<T2>

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

type Output = Cartesian<T>

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

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

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

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

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

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

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

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

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

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

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

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

fn add_assign(&mut self, rhs: T1)

§Example

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

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

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

fn arg(&self) -> T

§Example

fn ang(&self) -> T

§Example

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

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

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

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

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

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

fn conj(&self) -> T

§Example

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

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

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

fn default() -> Cartesian<T>

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

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

§Example

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

type Output = Cartesian<T>

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

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

type Output = Cartesian<T>

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

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

type Output = Cartesian<T>

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

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

type Output = Cartesian<T>

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

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

type Output = Cartesian<T>

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

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

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

Struct Cartesian

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

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

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

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