Struct ComplexVector 

pub struct ComplexVector<T, V>
where
    T: Transcendental,
    V: Vector<T, 4>,
{ /* private fields */ }

Two complex numbers: [re0, im0, re1, im1] in one 4‑lane vector.

Implementations

impl<T, V> ComplexVector<T, V>

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

pub fn from_raw(data: V) -> ComplexVector<T, V>

Wrap a raw Vector<T,4> in [re0, im0, re1, im1] interleaved layout.

pub fn splat_pair(re: T, im: T) -> ComplexVector<T, V>

Duplicate a single (re, im) pair into both lane pairs.

pub fn from_pair(c: (T, T)) -> ComplexVector<T, V>

Create from a single (re, im) pair, duplicated to both lane pairs.

pub fn from_two(c0: (T, T), c1: (T, T)) -> ComplexVector<T, V>

Create from two possibly-different complex pairs. Pairs go to lanes (0,1) and (2,3) respectively.

pub fn inner(&self) -> &V

Return a reference to the raw Vector<T,4>.

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

Extract the i-th lane from the underlying vector.

pub fn re0(&self) -> T

Real part of the first complex element (lane 0).

pub fn im0(&self) -> T

Imaginary part of the first complex element (lane 1).

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

Complex conjugate.

pub fn cmul(&self, other: &ComplexVector<T, V>) -> ComplexVector<T, V>

Complex multiplication: self * other (element-wise).

pub fn cadd(&self, other: &ComplexVector<T, V>) -> ComplexVector<T, V>

Complex addition: self + other.

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

Complex subtraction: self - other.

pub fn norm_sqr(&self) -> (T, T)

Magnitude squared per complex element: re² + im² (lane‑pair summed).

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

Multiply both real and imaginary parts by a real scalar.

pub fn to_complex0(&self) -> (T, T)

Extract the first complex value as (re, im).

pub fn to_complex1(&self) -> (T, T)

Extract the second complex value as (re, im).

pub fn map_complex<F>(&self, f: F) -> ComplexVector<T, V>

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

Apply a closure to each of the two complex elements.

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

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

Trait Implementations

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

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

type Output = ComplexVector<T, V>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

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

Performs the += operation.

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

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

fn clone(&self) -> ComplexVector<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 ComplexVector<T, V>

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

impl<T, V> Debug for ComplexVector<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 ComplexVector<T, V>

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

Complex division: (a+bi)/(c+di) = (ac+bd)/(c²+d²) + i*(bc-ad)/(c²+d²).

type Output = ComplexVector<T, V>

The resulting type after applying the / operator.

fn div(self, rhs: ComplexVector<T, V>) -> ComplexVector<T, V>

Performs the / operation.

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

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

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

Performs the /= operation.

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

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

type Output = ComplexVector<T, V>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

cv * t — scale both complex elements by a real scalar.

type Output = ComplexVector<T, V>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

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

Performs the *= operation.

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

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

type Output = ComplexVector<T, V>

The resulting type after applying the - operator.

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

Performs the unary - operation.

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

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

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

Equality operator ==.

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

Inequality operator !=.

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

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

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

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

type Output = ComplexVector<T, V>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

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

Performs the -= operation.