Struct ComplexSoa 

pub struct ComplexSoa<T: Transcendental, V: Vector<T, 4>> {
    pub re: V,
    pub im: V,
    /* private fields */
}

Four complex numbers, separate re/im arrays. For SIMD‑heavy operations.

Fields

re: V

Real parts of four complex numbers (one per lane).

im: V

Imaginary parts of four complex numbers (one per lane).

Implementations

impl<T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>> ComplexSoa<T, V>

pub fn load(re_slice: &[T], im_slice: &[T]) -> Self

Load four complex numbers from separate re/im slices.

pub fn from_pairs(p: [(T, T); 4]) -> Self

Create from four (re, im) pairs.

pub fn store(&self, re_slice: &mut [T], im_slice: &mut [T])

Store back to separate re/im slices.

pub fn extract_complex(&self, i: usize) -> (T, T)

Extract a single complex value at lane i: returns (re, im).

pub fn to_complexes(&self) -> [(T, T); 4]

Extract all four complex values as an array of (re, im) pairs.

pub fn map_complex<F>(&self, f: F) -> Self

where F: Fn((T, T)) -> (T, T),

Apply a closure to each of the four complex elements.

pub fn iter_complex(&self) -> impl Iterator<Item = (T, T)>

Iterate over the four complex elements as (re, im) pairs.

pub fn cmul(&self, other: &Self) -> Self

Complex multiplication: self * other on four numbers at once.

pub fn cmul_add(&mut self, a: &Self, b: &Self)

Complex multiply-accumulate: self += a * b.

pub fn conj(&self) -> Self

Complex conjugate.

pub fn norm_sqr(&self) -> V

Squared magnitude (re² + im²) per lane.

pub fn all_norm_sqr_lt(&self, threshold_sq: T) -> bool

True if all four norms are below threshold_sq.

pub fn cadd(&self, other: &Self) -> Self

Complex addition: self + other.

pub fn csub(&self, other: &Self) -> Self

Complex subtraction: self - other.

pub fn scale_real(&self, scalar: V) -> Self

Multiply both re and im by a real scalar vector (per-lane).

Trait Implementations

impl<T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>> Add for ComplexSoa<T, V>

type Output = ComplexSoa<T, V>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>> AddAssign for ComplexSoa<T, V>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T: Clone + Transcendental, V: Clone + Vector<T, 4>> Clone for ComplexSoa<T, V>

fn clone(&self) -> ComplexSoa<T, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy + Transcendental, V: Copy + Vector<T, 4>> Copy for ComplexSoa<T, V>

impl<T: Debug + Transcendental, V: Debug + Vector<T, 4>> Debug for ComplexSoa<T, V>

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

Formats the value using the given formatter.

impl<T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>> Div for ComplexSoa<T, V>

Complex division (four at once): (re+im·i)/(rre+rim·i) per lane.

denom = rre² + rim², then re_out = (re·rre + im·rim)/denom, im_out = (im·rre − re·rim)/denom.

type Output = ComplexSoa<T, V>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>> DivAssign for ComplexSoa<T, V>

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>> Mul for ComplexSoa<T, V>

type Output = ComplexSoa<T, V>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>> Mul<V> for ComplexSoa<T, V>

csoa * sv — scale all four complex numbers by a real vector (per‑lane).

type Output = ComplexSoa<T, V>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>> MulAssign for ComplexSoa<T, V>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>> Neg for ComplexSoa<T, V>

type Output = ComplexSoa<T, V>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<T: PartialEq + Transcendental, V: PartialEq + Vector<T, 4>> PartialEq for ComplexSoa<T, V>

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

Equality operator ==.

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

Inequality operator !=.

impl<T: PartialEq + Transcendental, V: PartialEq + Vector<T, 4>> StructuralPartialEq for ComplexSoa<T, V>

impl<T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>> Sub for ComplexSoa<T, V>

type Output = ComplexSoa<T, V>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>> SubAssign for ComplexSoa<T, V>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.