Struct ComplexSoa 

pub struct ComplexSoa<T, V>
where
    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, V> ComplexSoa<T, V>

where T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>,

pub fn load(re_slice: &[T], im_slice: &[T]) -> ComplexSoa<T, V>

Load four complex numbers from separate re/im slices.

pub fn from_pairs(p: [(T, T); 4]) -> ComplexSoa<T, V>

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) -> ComplexSoa<T, V>

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: &ComplexSoa<T, V>) -> ComplexSoa<T, V>

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

pub fn cmul_add(&mut self, a: &ComplexSoa<T, V>, b: &ComplexSoa<T, V>)

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

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

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: &ComplexSoa<T, V>) -> ComplexSoa<T, V>

Complex addition: self + other.

pub fn csub(&self, other: &ComplexSoa<T, V>) -> ComplexSoa<T, V>

Complex subtraction: self - other.

pub fn scale_real(&self, scalar: V) -> ComplexSoa<T, V>

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

Trait Implementations

impl<T, V> Add for ComplexSoa<T, V>

where T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>,

type Output = ComplexSoa<T, V>

The resulting type after applying the + operator.

fn add(self, rhs: ComplexSoa<T, V>) -> ComplexSoa<T, V>

Performs the + operation.

impl<T, V> AddAssign for ComplexSoa<T, V>

where T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>,

fn add_assign(&mut self, rhs: ComplexSoa<T, V>)

Performs the += operation.

impl<T, V> Clone for ComplexSoa<T, V>

where T: Clone + Transcendental, V: Clone + Vector<T, 4>,

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, V> Copy for ComplexSoa<T, V>

where T: Copy + Transcendental, V: Copy + Vector<T, 4>,

impl<T, V> Debug for ComplexSoa<T, V>

where T: Debug + Transcendental, V: Debug + Vector<T, 4>,

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

Formats the value using the given formatter.

impl<T, V> Div for ComplexSoa<T, V>

where T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>,

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: ComplexSoa<T, V>) -> ComplexSoa<T, V>

Performs the / operation.

impl<T, V> DivAssign for ComplexSoa<T, V>

where T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>,

fn div_assign(&mut self, rhs: ComplexSoa<T, V>)

Performs the /= operation.

impl<T, V> Mul for ComplexSoa<T, V>

where T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>,

type Output = ComplexSoa<T, V>

The resulting type after applying the * operator.

fn mul(self, rhs: ComplexSoa<T, V>) -> ComplexSoa<T, V>

Performs the * operation.

impl<T, V> Mul<V> for ComplexSoa<T, V>

where T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>,

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) -> ComplexSoa<T, V>

Performs the * operation.

impl<T, V> MulAssign for ComplexSoa<T, V>

where T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>,

fn mul_assign(&mut self, rhs: ComplexSoa<T, V>)

Performs the *= operation.

impl<T, V> Neg for ComplexSoa<T, V>

where T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>,

type Output = ComplexSoa<T, V>

The resulting type after applying the - operator.

fn neg(self) -> ComplexSoa<T, V>

Performs the unary - operation.

impl<T, V> PartialEq for ComplexSoa<T, V>

where T: PartialEq + Transcendental, V: PartialEq + Vector<T, 4>,

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

Equality operator ==.

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

Inequality operator !=.

impl<T, V> StructuralPartialEq for ComplexSoa<T, V>

where T: PartialEq + Transcendental, V: PartialEq + Vector<T, 4>,

impl<T, V> Sub for ComplexSoa<T, V>

where T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>,

type Output = ComplexSoa<T, V>

The resulting type after applying the - operator.

fn sub(self, rhs: ComplexSoa<T, V>) -> ComplexSoa<T, V>

Performs the - operation.

impl<T, V> SubAssign for ComplexSoa<T, V>

where T: Transcendental, V: Vector<T, 4> + VectorMask<T, 4>,

fn sub_assign(&mut self, rhs: ComplexSoa<T, V>)

Performs the -= operation.