Struct matrix::complex::Complex

pub struct Complex {
    pub real: f32,
    pub imag: f32,
}

A struct representing a complex number with f32 real and imaginary components.

Fields

real: f32

imag: f32

Implementations

impl Complex

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

Creates a new Complex number given a real and imaginary part.

Arguments

• real - The real component of the complex number.
• imag - The imaginary component of the complex number.

Returns

A new Complex number with the specified real and imaginary components.

Example

use matrix::Complex;

let complex_num = Complex::new(3.0, 4.0);
assert_eq!(complex_num.real, 3.0);
assert_eq!(complex_num.imag, 4.0);

pub fn conjugate(self) -> Self

Returns the conjugate of the complex number.

The conjugate of a complex number a + bi is given by a - bi.

Returns

A new Complex number with the same real component and a negated imaginary component.

Example

use matrix::Complex;

let complex_num = Complex::new(3.0, 4.0);
let conjugate = complex_num.conjugate();
assert_eq!(conjugate, Complex::new(3.0, -4.0));

pub fn magnitude(&self) -> f32

Computes the magnitude (or modulus) of the complex number.

The magnitude of a complex number ( z = a + bi ) is calculated as:

where a is the real part and b is the imaginary part of the complex number.

Returns

A f64 value representing the magnitude of the complex number.

Example

use matrix::Complex;

let complex_num = Complex::new(3.0, 4.0);
assert_eq!(complex_num.magnitude(), 5.0);

Trait Implementations

impl Add for Complex

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

Adds two Complex numbers.

Given two complex numbers a + bi and c + di, the sum is:

Arguments

• self - The first Complex number.
• other - The second Complex number to add.

Returns

A new Complex number which is the sum of self and other.

Example

use matrix::Complex;

let a = Complex::new(3.0, 4.0);
let b = Complex::new(1.0, 2.0);
assert_eq!(a + b, Complex::new(4.0, 6.0));

type Output = Complex

The resulting type after applying the + operator.

impl AddAssign for Complex

fn add_assign(&mut self, other: Self)

Adds another Complex number to self.

impl Clone for Complex

fn clone(&self) -> Complex

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Complex

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

Formats the value using the given formatter.

impl Display for Complex

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

Formats the Complex for display.

Parameters

• f: A mutable reference to a fmt::Formatter for formatting.

Returns

• fmt::Result: Indicates success or failure of the formatting.

impl Div for Complex

fn div(self, other: Self) -> Self::Output

Divides one Complex number by another.

Given two complex numbers a + bi and c + di, the quotient is:

Arguments

• self - The Complex number to be divided.
• other - The Complex number to divide by.

Returns

A new Complex number which is the quotient of self and other.

Example

use matrix::Complex;

let a = Complex::new(3.0, 2.0);
let b = Complex::new(1.0, -1.0);
let result = a / b;
assert!((result.real - 0.5).abs() < 1e-10);
assert!((result.imag - 2.5).abs() < 1e-10);

type Output = Complex

The resulting type after applying the / operator.

impl DivAssign for Complex

fn div_assign(&mut self, other: Self)

Divides self by another Complex number.

impl Mul for Complex

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

Multiplies two Complex numbers.

Given two complex numbers a + bi and c + di, the product is:

Arguments

• self - The first Complex number.
• other - The second Complex number to multiply.

Returns

A new Complex number which is the product of self and other.

Example

use matrix::Complex;

let a = Complex::new(3.0, 4.0);
let b = Complex::new(1.0, 2.0);
assert_eq!(a * b, Complex::new(-5.0, 10.0));

type Output = Complex

The resulting type after applying the * operator.

impl MulAssign for Complex

fn mul_assign(&mut self, other: Self)

Multiplies self by another Complex number.

impl PartialEq for Complex

fn eq(&self, other: &Complex) -> 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 PartialOrd for Complex

fn partial_cmp(&self, other: &Complex) -> 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 Scalar for Complex

fn fma(a: Self, b: Self, c: Self) -> Self

Fused Multiply-Add (FMA): Computes a * b + c for Complex numbers.

fn fms(a: Self, b: Self, c: Self) -> Self

Fused Multiply-Subtract (FMS): Computes a * b - c for Complex numbers.

fn from_f32(value: f32) -> Self

Converts an f32 value to a Complex number with a zero imaginary part.

Arguments

• value - The f32 value to convert.

Returns

A new Complex number with the real part set to value and imaginary part set to 0.

fn to_f32(self) -> f32

Converts the real part of the Complex number to f32, ignoring the imaginary part.

Returns

The real part of self as an f32 value.

impl Sub for Complex

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

Subtracts one Complex number from another.

Given two complex numbers a + bi and c + di, the difference is:

Arguments

• self - The Complex number to be subtracted from.
• other - The Complex number to subtract.

Returns

A new Complex number which is the difference of self and other.

Example

use matrix::Complex;

let a = Complex::new(3.0, 4.0);
let b = Complex::new(1.0, 2.0);
assert_eq!(a - b, Complex::new(2.0, 2.0));

type Output = Complex

The resulting type after applying the - operator.

impl SubAssign for Complex

fn sub_assign(&mut self, other: Self)

Subtracts another Complex number from self.

impl Zero for Complex

fn zero() -> Self

Returns the additive identity of Complex, which is 0 + 0i.

fn is_zero(&self) -> bool

Checks if the Complex number is zero (both real and imaginary parts are zero).

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl Copy for Complex

impl StructuralPartialEq for Complex