Struct quantr::Complex

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

Generic complex number.

Fields

re: T

im: T

Implementations

impl Complex<f64>

pub fn exp_im(theta: f64) -> Complex<f64>

Returns exp(i*theta) as a complex number.

Example

use quantr::Complex;
use quantr::complex_im;
use std::f64::consts::PI;

let num: Complex<f64> = Complex::<f64>::exp_im(0.5f64 * PI);

impl Complex<f32>

pub fn exp_im(theta: f32) -> Complex<f32>

Returns exp(i*theta) as a complex number.

Example

use quantr::Complex;
use quantr::complex_im;
use std::f32::consts::PI;

let num: Complex<f32> = Complex::<f32>::exp_im(0.5f32 * PI);

impl<T: Add<Output = T> + Mul<Output = T> + Copy> Complex<T>

pub fn abs_square(self) -> T

Absolute square of a complex number, that is |z|^2 = a^2+b^2 where z = a + bi.

Example

use quantr::Complex;

let z: Complex<i16> = Complex{ re: 3i16, im: 4i16 };
assert_eq!(z.abs_square(), 25i16);

impl<T: Add<Output = T> + Mul<Output = T> + Sqr + Copy> Complex<T>

pub fn abs(&self) -> T

Absolute value of a complex number, that is |z| = Sqrt(a^2+b^2) where z = a + bi.

Example

use quantr::Complex;

let z: Complex<f64> = Complex{ re: 3f64, im: 4f64 };
assert_eq!(z.abs(), 5f64);

Trait Implementations

impl<T: Add<Output = T>> Add for Complex<T>

Addition of two generic complex numbers.

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

Example

use quantr::Complex;

let z1: Complex<i16> = Complex{ re: -4i16, im: 2i16 };
let z2: Complex<i16> = Complex{ re: 2i16, im: 7i16 };
assert_eq!(z1 + z2, Complex{ re: -2i16, im: 9i16 });

type Output = Complex<T>

The resulting type after applying the + operator.

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

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

Returns a copy 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: Display> Display for Complex<T>

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

Formats the value using the given formatter.

impl Mul<Complex<f64>> for f64

Multiplication Complex<f64> * f64.

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

RHS scalar multiplication: Complex<f64> * f64.

Example

use quantr::Complex;

let z1: f64 = 2f64;
let z2: Complex<f64> = Complex{ re: 2f64, im: 7f64 };
assert_eq!(z2 * z1, Complex{ re: 4f64, im: 14f64 });

type Output = Complex<f64>

The resulting type after applying the * operator.

impl Mul<f64> for Complex<f64>

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

LHS scalar multiplication: f64 * Complex<f64>.

Example

use quantr::Complex;

let z1: f64 = 2f64;
let z2: Complex<f64> = Complex{ re: 2f64, im: 7f64 };
assert_eq!(z1 * z2, Complex{ re: 4f64, im: 14f64 });

type Output = Complex<f64>

The resulting type after applying the * operator.

impl<T: Mul<Output = T> + Add<Output = T> + Sub<Output = T> + Copy> Mul for Complex<T>

Multiplying two generic complex numbers.

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

Example

use quantr::Complex;

let z1: Complex<i16> = Complex{ re: -4i16, im: 2i16 };
let z2: Complex<i16> = Complex{ re: 2i16, im: 7i16 };
assert_eq!(z1 * z2, Complex{ re: -22i16, im: -24i16 });

type Output = Complex<T>

The resulting type after applying the * operator.

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

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

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

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: Sub<Output = T>> Sub for Complex<T>

Subtracts two generic complex numbers.

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

Example

use quantr::Complex;

let z1: Complex<i16> = Complex{ re: -4i16, im: 2i16 };
let z2: Complex<i16> = Complex{ re: 2i16, im: 7i16 };
assert_eq!(z1 - z2, Complex{ re: -6i16, im: -5i16 });

type Output = Complex<T>

The resulting type after applying the - operator.

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

impl<T> StructuralPartialEq for Complex<T>