Struct Complex 

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

A complex number with real and imaginary parts of type T.

Examples

let z = Complex::new(3.0_f64, 4.0);
assert_eq!(z.norm(), 5.0);

Fields

re: T

Real part.

im: T

Imaginary part.

Implementations

impl<T: Float> Complex<T>

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

Create a new complex number from real and imaginary parts.

Examples

let z = Complex::new(1.0_f64, 2.0);
assert_eq!(z.re, 1.0);
assert_eq!(z.im, 2.0);

pub fn from_real(re: T) -> Self

Create a complex number from a real value (imaginary part is zero).

Examples

let z = Complex::from_real(3.0_f64);
assert_eq!(z.im, 0.0);

pub fn from_polar(r: T, theta: T) -> Self

Create a complex number from polar form: r * (cos(theta) + i*sin(theta)).

Examples

let z = Complex::from_polar(1.0_f64, 0.0_f64);
assert!((z.re - 1.0).abs() < 1e-15);
assert!(z.im.abs() < 1e-15);

pub fn conj(self) -> Self

Complex conjugate: flips the sign of the imaginary part.

Examples

let z = Complex::new(3.0_f64, 4.0);
let c = z.conj();
assert_eq!(c.re, 3.0);
assert_eq!(c.im, -4.0);

pub fn norm_sqr(self) -> T

Squared modulus: re² + im². Avoids the sqrt in norm.

Examples

let z = Complex::new(3.0_f64, 4.0);
assert_eq!(z.norm_sqr(), 25.0);

pub fn norm(self) -> T

Modulus (absolute value): sqrt(re² + im²).

pub fn arg(self) -> T

Phase angle (argument): atan2(im, re).

Examples

let z = Complex::new(0.0_f64, 1.0); // i
let angle = z.arg();
assert!((angle - std::f64::consts::FRAC_PI_2).abs() < 1e-10);

pub fn exp(self) -> Self

Complex exponential: e^(a+bi) = e^a * (cos b + i sin b).

Examples

// e^0 = 1
let z = Complex::new(0.0_f64, 0.0);
let e = z.exp();
assert!((e.re - 1.0).abs() < 1e-15);
assert!(e.im.abs() < 1e-15);

pub fn ln(self) -> Self

Complex natural logarithm: ln|z| + i*arg(z).

Examples

// ln(1) = 0
let z = Complex::new(1.0_f64, 0.0);
let l = z.ln();
assert!(l.re.abs() < 1e-15);
assert!(l.im.abs() < 1e-15);

pub fn sqrt(self) -> Self

Complex square root.

Uses the principal branch: sqrt(r) * (cos(theta/2) + i*sin(theta/2)).

pub fn pow(self, n: T) -> Self

Complex power: z^n = e^(n * ln(z)).

Examples

// (1+0i)^5 = 1
let z = Complex::new(1.0_f64, 0.0);
let p = z.pow(5.0_f64);
assert!((p.re - 1.0).abs() < 1e-10);
assert!(p.im.abs() < 1e-10);

pub fn is_finite(self) -> bool

Returns true if both real and imaginary parts are finite.

Examples

assert!(Complex::new(1.0_f64, 2.0).is_finite());
assert!(!Complex::new(f64::INFINITY, 0.0).is_finite());

pub fn is_nan(self) -> bool

Returns true if either part is NaN.

Examples

assert!(!Complex::new(1.0_f64, 2.0).is_nan());
assert!(Complex::new(f64::NAN, 0.0).is_nan());

impl<T: Float> Complex<T>

pub fn i() -> Self

The imaginary unit i.

Examples

let i = Complex::<f64>::i();
assert_eq!(i.re, 0.0);
assert_eq!(i.im, 1.0);

Trait Implementations

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

type Output = Complex<T>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Complex<T>

The resulting type after applying the + operator.

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

Performs the + operation.

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

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

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

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

Returns a duplicate 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: Default> Default for Complex<T>

fn default() -> Complex<T>

Returns the “default value” for a type.

impl<T: Float + Display> Display for Complex<T>

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

Formats the value using the given formatter.

impl<T: Float> Div<T> for Complex<T>

type Output = Complex<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Float> Div for Complex<T>

type Output = Complex<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Float> DivAssign for Complex<T>

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<T: Float> Mul<T> for Complex<T>

type Output = Complex<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Float> Mul for Complex<T>

type Output = Complex<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Float> MulAssign for Complex<T>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<T: Float> Neg for Complex<T>

type Output = Complex<T>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

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

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T: Float> PartialOrd for Complex<T>

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

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

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

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

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Float> Scalar for Complex<T>

fn zero() -> Self

The additive identity (0).

fn one() -> Self

The multiplicative identity (1).

fn from_usize(v: usize) -> Self

Convert from usize (used for index / shape arithmetic).

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

type Output = Complex<T>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Complex<T>

The resulting type after applying the - operator.

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

Performs the - operation.

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

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<T: Float> Sum for Complex<T>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

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

impl<T> StructuralPartialEq for Complex<T>