Struct ComplexF64 

pub struct ComplexF64 {
    pub re: f64,
    pub im: f64,
}

A complex number with f64 real and imaginary parts.

Arithmetic follows the fixed-sequence protocol to prevent FMA drift.

Fields

re: f64

im: f64

Implementations

impl ComplexF64

pub const ZERO: ComplexF64

Zero.

pub const ONE: ComplexF64

One.

pub const I: ComplexF64

Imaginary unit.

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

Create a new complex number.

pub fn real(re: f64) -> Self

Create a purely real complex number.

pub fn imag(im: f64) -> Self

Create a purely imaginary complex number.

pub fn norm_sq(self) -> f64

Squared magnitude: |z|^2 = re^2 + im^2.

pub fn abs(self) -> f64

Magnitude: |z| = sqrt(re^2 + im^2).

pub fn conj(self) -> Self

Complex conjugate: (a - bi).

pub fn mul_fixed(self, rhs: Self) -> Self

Fixed-Sequence Complex Multiplication.

Explicitly computes four multiplications and two additions in a deterministic order, preventing FMA contraction:

t1 = a.re * b.re
t2 = a.im * b.im
t3 = a.re * b.im
t4 = a.im * b.re
result.re = t1 - t2
result.im = t3 + t4

FMA Prevention

By storing intermediates in local variables and computing each step explicitly, we prevent LLVM from fusing operations into FMA instructions, which would cause different rounding on platforms with/without hardware FMA support.

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

Complex addition: (a+bi) + (c+di) = (a+c) + (b+d)i.

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

Complex subtraction: (a+bi) - (c+di) = (a-c) + (b-d)i.

pub fn neg(self) -> Self

Complex negation: -(a+bi) = (-a) + (-b)i.

pub fn div_fixed(self, rhs: Self) -> Self

Fixed-Sequence Complex Division.

Computes (a+bi) / (c+di) using a fixed sequence:

denom = c*c + d*d         (two muls, one add — ordered)
re = (a*c + b*d) / denom  (two muls, one add, one div)
im = (b*c - a*d) / denom  (two muls, one sub, one div)

Division by zero (0+0i) produces NaN/Inf stably (no panic).

pub fn scale(self, s: f64) -> Self

Scalar multiplication: s * (a+bi) = (sa) + (sb)i.

pub fn is_nan(self) -> bool

Check if NaN in either component.

pub fn is_finite(self) -> bool

Check if both components are finite.

Trait Implementations

impl Clone for ComplexF64

fn clone(&self) -> ComplexF64

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ComplexF64

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

Formats the value using the given formatter.

impl Display for ComplexF64

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

Formats the value using the given formatter.

impl PartialEq for ComplexF64

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

impl StructuralPartialEq for ComplexF64