Struct Complex 

#[repr(C)]
pub struct Complex<V> {
    pub re: V,
    pub im: V,
}

A complex number re + im*i.

The derived PartialOrd is lexicographic on (re, im), matching PartialOrdVector. The crate docs cover the rest of the ordering/sign/rounding semantics.

Fields

re: V

The real part.

im: V

The imaginary part.

Implementations

impl<V: RealFloatVector> Complex<V>

pub fn splat_parts(re: V::Element, im: V::Element) -> Self

Splat a real and imaginary part across every lane.

impl<V: RealValue> Complex<V>

pub const ZERO: Self

Zero: 0 + 0i.

pub const ONE: Self

One: 1 + 0i.

pub const I: Self

The imaginary unit: 0 + 1i.

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

Creates a complex number with the given real and imaginary parts.

pub const fn real(re: V) -> Self

Creates a complex number with the given real part and zero imaginary part.

pub const fn imag(im: V) -> Self

Creates a complex number with zero real part and the given imaginary part.

pub fn conj(self) -> Self

The complex conjugate: re - im*i.

pub fn norm_sqr(self) -> V

The squared modulus $|z|^2 = re^2 + im^2$.

Cheaper than the modulus (no square root), but it squares the range, so it overflows or underflows near the limits of the format.

pub fn inv(self) -> Self

The multiplicative inverse $1/z = \bar{z}/|z|^2$.

Inherits the range limits of norm_sqr; the scaled form is finv.

Trait Implementations

impl<V: RealValue> Add for Complex<V>

type Output = Complex<V>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<V: RealValue> Add<V> for Complex<V>

type Output = Complex<V>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<V: RealValue, T> AddAssign<T> for Complex<V>

where Self: Add<T, Output = Self>,

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<V: RealFloatVector, Rhs> AddAssignMasked<<V as GenericVector>::Mask, Rhs> for Complex<V>

where Complex<V>: Add<Rhs, Output = Self>,

fn add_assign_c(&mut self, mask: V::Mask, rhs: Rhs)

Computes AddAssign with rhs where mask is true.

fn add_assign_m(&mut self, src: Self, mask: V::Mask, rhs: Rhs)

Merges AddAssign with src using mask, assigning src where mask is false.

fn add_assign_z(&mut self, mask: V::Mask, rhs: Rhs)

Computes AddAssign masked (zeroed where mask is false).

impl<V: RealFloatVector, Rhs> AddMasked<<V as GenericVector>::Mask, Rhs> for Complex<V>

where Complex<V>: Add<Rhs, Output = Self>,

fn add_c(self, mask: V::Mask, rhs: Rhs) -> Self

Computes Add with rhs where mask is true.

fn add_m(self, src: Self, mask: V::Mask, rhs: Rhs) -> Self

Merges Add with src using mask, returning src where mask is false.

fn add_z(self, mask: V::Mask, rhs: Rhs) -> Self

Computes Add masked (zeroed where mask is false).

impl<V: RealFloatVector> AddSubExt for Complex<V>

type Output = Complex<V>

The result of the lane-alternating operation.

fn addsub(self, b: Self) -> Self

[a0 - b0, a1 + b1, a2 - b2, ...] - even lanes subtract, odd lanes add.

fn fmaddsub(self, b: Self, c: Self) -> Self

[a0*b0 - c0, a1*b1 + c1, ...] - fused multiply then addsub.

fn fmsubadd(self, b: Self, c: Self) -> Self

[a0*b0 + c0, a1*b1 - c1, ...] - fused multiply then subadd (opposite parity).

impl<V: RealFloatVector> AddSubExtMasked<<V as GenericVector>::Mask> for Complex<V>

fn addsub_c(self, mask: V::Mask, b: Self) -> Self

addsub where mask is true, else self.

fn addsub_m(self, src: Self, mask: V::Mask, b: Self) -> Self

addsub where mask is true, else src.

fn addsub_z(self, mask: V::Mask, b: Self) -> Self

addsub where mask is true, else zero.

fn fmaddsub_c(self, mask: V::Mask, b: Self, c: Self) -> Self

fmaddsub where mask is true, else self.

fn fmaddsub_m(self, src: Self, mask: V::Mask, b: Self, c: Self) -> Self

fmaddsub where mask is true, else src.

fn fmaddsub_z(self, mask: V::Mask, b: Self, c: Self) -> Self

fmaddsub where mask is true, else zero.

fn fmsubadd_c(self, mask: V::Mask, b: Self, c: Self) -> Self

fmsubadd where mask is true, else self.

fn fmsubadd_m(self, src: Self, mask: V::Mask, b: Self, c: Self) -> Self

fmsubadd where mask is true, else src.

fn fmsubadd_z(self, mask: V::Mask, b: Self, c: Self) -> Self

fmsubadd where mask is true, else zero.

impl<V: RealFloatVector> Bounded for Complex<V>

fn min_value() -> Self

Returns the smallest finite number this type can represent

fn max_value() -> Self

Returns the largest finite number this type can represent

impl<FROM, TO> CastVector<Complex<FROM>> for Complex<TO>

where FROM: RealFloatVector + CastVector<TO>, TO: RealFloatVector + CastVector<FROM>,

fn cast_into(self) -> Complex<FROM>

Convert this vector into a vector of type FROM, lane-by-lane.

fn cast_from(from: Complex<FROM>) -> Self

Convert a vector of type FROM into Self, lane-by-lane, using as semantics on each element. See the trait docs for what float-to-int does with NaN and out-of-range lanes.

fn saturating_cast_from(from: FROM) -> Self

Convert lane-by-lane, clamping out-of-range values to Self’s element range rather than wrapping (integers) or producing a backend-defined value (float to int).

fn fast_cast_from(from: FROM) -> Self

Like cast_from, but may take a faster path that relaxes IEEE corner cases. See GenericVector::fast_cast.

fn fast_cast_into(self) -> FROM

Like cast_into, but may take a faster path that relaxes IEEE corner cases. See GenericVector::fast_cast.

impl<V: Clone> Clone for Complex<V>

fn clone(&self) -> Complex<V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: RealFloatVector> ComplexVector for Complex<V>

type Real = V

The real vector type of each component, in which a modulus or an argument is measured.

fn re(self) -> V

The real part.

fn im(self) -> V

The imaginary part.

fn from_parts(re: V, im: V) -> Self

Builds a complex vector from its real and imaginary parts.

unsafe fn store_streaming_block(self, ptr: *mut Self)

Non-temporal store of the whole block to ptr, in Self’s own memory layout (the planar/SoA [re | im] layout for Complex<V>), bypassing the cache. This is for relocating blocks within a [Self] buffer - e.g. an FFT transpose whose output is too large to cache - NOT the AoS boundary (that is store / store_streaming, which interleave re/im).

fn conj(self) -> Self

The complex conjugate re - im*i.

fn norm_sqr(self) -> V

The squared modulus $|z|^2 = re^2 + im^2$.

fn inv(self) -> Self

The multiplicative inverse $1/z = \bar{z}/|z|^2$.

fn norm_l1(self) -> V

The L1 (“Manhattan”) norm |re| + |im|, a real value.

fn real(re: Self::Real) -> Self

Builds a complex vector from a real part, with zero imaginary part.

impl<V: RealValue> ConstDefault for Complex<V>

const DEFAULT: Self = Self::ZERO

The constant default value.

impl<V: Copy> Copy for Complex<V>

impl<V: Debug> Debug for Complex<V>

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

Formats the value using the given formatter.

impl<V: Default> Default for Complex<V>

fn default() -> Complex<V>

Returns the “default value” for a type.

impl<V: RealValue> Div for Complex<V>

type Output = Complex<V>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<V: RealValue> Div<V> for Complex<V>

type Output = Complex<V>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<V: RealValue, T> DivAssign<T> for Complex<V>

where Self: Div<T, Output = Self>,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<V: RealFloatVector, Rhs> DivAssignMasked<<V as GenericVector>::Mask, Rhs> for Complex<V>

where Complex<V>: Div<Rhs, Output = Self>,

fn div_assign_c(&mut self, mask: V::Mask, rhs: Rhs)

Computes DivAssign with rhs where mask is true.

fn div_assign_m(&mut self, src: Self, mask: V::Mask, rhs: Rhs)

Merges DivAssign with src using mask, assigning src where mask is false.

fn div_assign_z(&mut self, mask: V::Mask, rhs: Rhs)

Computes DivAssign masked (zeroed where mask is false).

impl<V: RealFloatVector, Rhs> DivMasked<<V as GenericVector>::Mask, Rhs> for Complex<V>

where Complex<V>: Div<Rhs, Output = Self>,

fn div_c(self, mask: V::Mask, rhs: Rhs) -> Self

Computes Div with rhs where mask is true.

fn div_m(self, src: Self, mask: V::Mask, rhs: Rhs) -> Self

Merges Div with src using mask, returning src where mask is false.

fn div_z(self, mask: V::Mask, rhs: Rhs) -> Self

Computes Div masked (zeroed where mask is false).

impl<E: RealValue + Element> Element for Complex<E>

const ZERO: Self = Self::ZERO

const ONE: Self = Self::ONE

const ORDER_MAX: Self

The greatest value under this type’s natural total order, and the least.

const ORDER_MIN: Self

The least value under this type’s natural total order. See ORDER_MAX.

const HAS_UNORDERED: bool = E::HAS_UNORDERED

Whether values of this type can be unordered under PartialOrd - float NaN. false for every integer type.

const IS_FLOAT: bool = E::IS_FLOAT

Whether this is a floating-point element type. This is distinct from HAS_UNORDERED because some float types may not have NaN and so are ordered, but still have some special properties of floats.

type Signed = <E as Element>::Signed

SignedBits integer type to be used with operations that require signed counts, such as shifts.

type Unsigned = <E as Element>::Unsigned

Unsigned integer type to be used with operations that require unsigned counts, such as shifts.

fn from_i8(value: i8) -> Self

fn from_u8(value: u8) -> Self

fn from_u16(value: u16) -> Self

impl<E, V: RealFloatVector<Element = E>> ExpIntDetails<Complex<E>, Complex<V>> for Complex<V>

where Complex<V>: FloatVector<Element = Complex<E>, Mask = V::Mask>,

Available on crate feature special only.

All three of the shared expint kernel’s decisions change over C. Everything else about that kernel - the series, the Lentz continued fraction, the order recurrence - is inherited unchanged and simply runs in complex arithmetic.

fn invalid(z: Complex<V>) -> V::Mask

Nothing but NaN is out of domain.

Real E_N is a half-line function and the default NaNs out x < 0. E_N(z) is holomorphic on the whole cut plane |Arg z| < pi, so the negative reals are in-domain here, approached from above. The cut needs no handling of its own: all of the multivaluedness sits in the -ln z term of the series, and the principal ln this crate provides already carries exactly that branch.

fn cf_tiny() -> Complex<V>

The default sentinel, MIN_POSITIVE, cannot be used here: a complex reciprocal is conj(z) / |z|^2, and MIN_POSITIVE^2 underflows to zero, so the very first Lentz step divides by zero and every continued-fraction lane comes back NaN.

sqrt(MIN_POSITIVE) / EPSILON is the principled choice: the square root is the hard floor for surviving the squaring, and dividing by EPSILON backs off it far enough that the reciprocal’s square stays inside the exponent range too. Holds with room to spare for f32 and f64 alike.

fn use_series(z: Complex<V>) -> V::Mask

Lanes that should take the power series rather than the continued fraction.

impl<V: RealValue + FloatConsts> FloatConsts for Complex<V>

const NEG_ZERO: Self

Negative zero (-0) (only sign bit set)

const E: Self

Euler’s number (e)

const EULER_GAMMA: Self

Euler-Mascheroni constant (γ)

const PI_SQUARED: Self

$\pi^2$

const PI_CUBED: Self

$\pi^3$

const PI_FOURTH: Self

$\pi^4$

const FRAC_1_PI: Self

$1/\pi$

const FRAC_1_SQRT_2: Self

$1/\sqrt{2}$

const FRAC_1_SQRT_3: Self

$1/\sqrt{3}$

const FRAC_2_PI: Self

$2/\pi$

const FRAC_1_SQRT_PI: Self

$1/\sqrt{\pi}$

const FRAC_2_SQRT_PI: Self

$2/\sqrt{\pi}$

const FRAC_SQRT_PI_2: Self

$\sqrt{\pi}/2$

const FRAC_1_SQRT_TAU: Self

$1/\sqrt{2\pi}$

const FRAC_PI_2: Self

$\pi/2$

const FRAC_PI_3: Self

$\pi/3$

const FRAC_PI_4: Self

$\pi/4$

const FRAC_PI_6: Self

$\pi/6$

const FRAC_PI_8: Self

$\pi/8$

const FRAC_PI_180: Self

$\pi/180$

const FRAC_180_PI: Self

$180/\pi$

const LN_2: Self

$\ln 2$

const LN_10: Self

$\ln 10$

const LN_PI: Self

$\ln \pi$

const FRAC_LN_PI_2: Self

$frac{1}{2}\ln \pi$

const LOG2_10: Self

$\log_2 10$

const LOG2_E: Self

$\log_2 e$

const LOG10_2: Self

$\log_{10} 2$

const LOG10_E: Self

$\log_{10} e$

const PI: Self

Archimedes’ constant (π)

const SQRT_2: Self

$\sqrt{2}$

const SQRT_3: Self

$\sqrt{3}$

const SQRT_E: Self

$\sqrt{e}$

const EPSILON: Self

The machine epsilon

const SQRT_EPSILON: Self

The square root of the machine epsilon ($\sqrt{arepsilon}$)

const FOURTH_ROOT_EPSILON: Self

The fourth root of the machine epsilon ($\sqrt[4]{arepsilon}$)

const TAU: Self

The full circle constant (τ)

const SQRT_FRAC_PI_2: Self

$\sqrt{\pi/2}$

const SQRT_TAU: Self

$\sqrt{2\pi}$

const PHI: Self

The golden ratio (φ)

const FRAC_1_3: Self

$1/3$

const FRAC_2_3: Self

$2/3$

const FRAC_1_4: Self

1/4

const FRAC_1_6: Self

1/6

const FRAC_NEG_1_E: Self

-1/e

impl<E: RealValue + FloatElement> FloatElement for Complex<E>

fn sqrt(this: Self) -> Self

The principal square root, in Kahan’s form; see FloatVector::sqrt below for why the symmetric formula is unusable.

const HAS_INFINITY: bool = E::HAS_INFINITY

Does the format support Infinity? If FALSE, overflow saturates to MAX_FINITE instead of INF. (e.g., E4M3 = false, E5M2 = true)

const HAS_SIGNED_ZERO: bool = E::HAS_SIGNED_ZERO

Does the format distinguish between +0 and -0? (Usually true, but some integer-like quantizations might not)

const HAS_SUBNORMALS: bool = E::HAS_SUBNORMALS

Does the format support subnormal numbers? If FALSE, any value smaller than MinNormal is flushed to zero (FTZ).

type ConstInt<const VAL: LargeInt> = ComplexIntConst<E, VAL>

Marker type for splatting a compile-time integer constant as this float type.

type ConstRatio<const NUM: LargeInt, const DEN: LargeInt> = ComplexRatioConst<E, NUM, DEN>

Marker type for splatting a compile-time rational constant (N/D) as this float type.

fn floor(this: Self) -> Self

fn ceil(this: Self) -> Self

fn round(this: Self) -> Self

fn trunc(this: Self) -> Self

fn next_up(this: Self) -> Self

fn next_down(this: Self) -> Self

fn try_from_int(value: LargeInt) -> Option<Self>

Try to represent this LargeInt value as this float type, returning None if it cannot be represented exactly.

fn try_from_ratio(n: LargeInt, d: LargeInt) -> Option<Self>

fn from_int(value: i64) -> Self

fn from_ratio(n: i64, d: i64) -> Self

fn fract(value: Self) -> Self

impl<V: RealFloatVector> FloatVector for Complex<V>

fn sqrt(self) -> Self

The principal square root, with a branch cut on the negative real axis.

fn rcp(self) -> Self

$1/z = \bar{z}/|z|^2$

fn rsqrt(self) -> Self

$1/\sqrt{z} = \overline{\sqrt{z}}/|z|$, since $|\sqrt{z}|^2 = |z|$.

const HALF: Self

The value 0.5 represented in this vector type.

const NEG_ZERO: Self

The value -0.0 represented in this vector type.

const EPSILON: Self

Hardware epsilon value in this vector type.

const INFINITY: Self

The value infinity represented in this vector type.

const NEG_INFINITY: Self

The value -infinity represented in this vector type.

const NAN: Self

The value NaN represented in this vector type.

const HAS_APPROX_RCP: bool = V::HAS_APPROX_RCP

true if the backend has a hardware approximate-reciprocal instruction (e.g. rcpps on x86). When false, rcp falls back to a full IEEE division and provides no speed advantage over Self::ONE / self.

const HAS_APPROX_RSQRT: bool = V::HAS_APPROX_RCP

true if the backend has a hardware approximate-reciprocal-square-root instruction (e.g. rsqrtps on x86). When false, rsqrt falls back to Self::ONE / self.sqrt().

type ExtendedPrecision = Complex<V>

If available, an extended precision floating point vector type corresponding to this vector type. E.g., for f32 vectors, this would be an f64 vector type.

fn is_nan(self) -> Self::Mask

Check if each element in the vector is NaN, returning a mask.

fn is_infinite(self) -> Self::Mask

Check if each element in the vector is infinite, returning a mask.

fn is_finite(self) -> Self::Mask

Check if each element in the vector is finite, returning a mask.

fn is_zero_or_subnormal(self) -> Self::Mask

Check if each element in the vector is zero or subnormal, returning a mask.

fn is_normal(self) -> Self::Mask

Check if each element in the vector is normal, returning a mask.

fn is_subnormal(self) -> Self::Mask

Check if each element in the vector is subnormal, returning a mask.

fn floor(self) -> Self

Lane-wise floor: largest integer less than or equal to each element.

fn ceil(self) -> Self

Lane-wise ceiling: smallest integer greater than or equal to each element, kept in the float representation.

fn round(self) -> Self

Lane-wise round-to-nearest.

fn trunc(self) -> Self

Lane-wise truncation toward zero (drops the fractional part), kept in the float representation.

fn fract(self) -> Self

Lane-wise fractional part: self - self.trunc().

fn mul_sign(self, sign: Self) -> Self

Effectively self * sign.signum(), multiplying the sign bits.

fn signed_zero(self) -> Self

Returns zero with the sign of self, i.e.: only the sign bit is set.

fn next_up(self) -> Self

Returns the next representable value greater than the current value, towards positive infinity.

fn next_down(self) -> Self

Returns the next representable value less than the current value, towards negative infinity.

unsafe fn block_autovectorization(&mut self)

Inhibit further LLVM auto-vectorization of code surrounding this call.

fn mix(self, a: Self, b: Self) -> Self

Linearly interpolates between a and b by self, where self is typically in the range [0, 1].

fn sqrt_c(self, mask: Self::Mask) -> Self

Lane-wise IEEE 754 square root.

fn sqrt_m(self, src: Self, mask: Self::Mask) -> Self

Lane-wise IEEE 754 square root.

fn sqrt_z(self, mask: Self::Mask) -> Self

Lane-wise IEEE 754 square root.

fn rsqrt_c(self, mask: Self::Mask) -> Self

Lane-wise approximate reciprocal square root.

fn rsqrt_m(self, src: Self, mask: Self::Mask) -> Self

Lane-wise approximate reciprocal square root.

fn rsqrt_z(self, mask: Self::Mask) -> Self

Lane-wise approximate reciprocal square root.

fn rcp_c(self, mask: Self::Mask) -> Self

Lane-wise approximate reciprocal: 1 / self.

fn rcp_m(self, src: Self, mask: Self::Mask) -> Self

Lane-wise approximate reciprocal: 1 / self.

fn rcp_z(self, mask: Self::Mask) -> Self

Lane-wise approximate reciprocal: 1 / self.

fn floor_c(self, mask: Self::Mask) -> Self

Lane-wise floor: largest integer less than or equal to each element.

fn floor_m(self, src: Self, mask: Self::Mask) -> Self

Lane-wise floor: largest integer less than or equal to each element.

fn floor_z(self, mask: Self::Mask) -> Self

Lane-wise floor: largest integer less than or equal to each element.

fn ceil_c(self, mask: Self::Mask) -> Self

Lane-wise ceiling: smallest integer greater than or equal to each element, kept in the float representation. Computes ceil when mask is true, returns self where false.

fn ceil_m(self, src: Self, mask: Self::Mask) -> Self

Lane-wise ceiling: smallest integer greater than or equal to each element, kept in the float representation. Merges ceil with src using mask.

fn ceil_z(self, mask: Self::Mask) -> Self

Lane-wise ceiling: smallest integer greater than or equal to each element, kept in the float representation. Computes ceil masked (zeroed where mask is false).

fn round_c(self, mask: Self::Mask) -> Self

Lane-wise round-to-nearest.

fn round_m(self, src: Self, mask: Self::Mask) -> Self

Lane-wise round-to-nearest.

fn round_z(self, mask: Self::Mask) -> Self

Lane-wise round-to-nearest.

fn trunc_c(self, mask: Self::Mask) -> Self

Lane-wise truncation toward zero (drops the fractional part), kept in the float representation. Computes trunc when mask is true, returns self where false.

fn trunc_m(self, src: Self, mask: Self::Mask) -> Self

Lane-wise truncation toward zero (drops the fractional part), kept in the float representation. Merges trunc with src using mask.

fn trunc_z(self, mask: Self::Mask) -> Self

Lane-wise truncation toward zero (drops the fractional part), kept in the float representation. Computes trunc masked (zeroed where mask is false).

fn fract_c(self, mask: Self::Mask) -> Self

Lane-wise fractional part: self - self.trunc().

fn fract_m(self, src: Self, mask: Self::Mask) -> Self

Lane-wise fractional part: self - self.trunc().

fn fract_z(self, mask: Self::Mask) -> Self

Lane-wise fractional part: self - self.trunc().

fn signed_zero_c(self, mask: Self::Mask) -> Self

Returns zero with the sign of self, i.e.: only the sign bit is set. Computes signed_zero when mask is true, returns self where false.

fn signed_zero_m(self, src: Self, mask: Self::Mask) -> Self

Returns zero with the sign of self, i.e.: only the sign bit is set. Merges signed_zero with src using mask.

fn signed_zero_z(self, mask: Self::Mask) -> Self

Returns zero with the sign of self, i.e.: only the sign bit is set. Computes signed_zero masked (zeroed where mask is false).

fn next_up_c(self, mask: Self::Mask) -> Self

Returns the next representable value greater than the current value, towards positive infinity. Computes next_up when mask is true, returns self where false.

fn next_up_m(self, src: Self, mask: Self::Mask) -> Self

Returns the next representable value greater than the current value, towards positive infinity. Merges next_up with src using mask.

fn next_up_z(self, mask: Self::Mask) -> Self

Returns the next representable value greater than the current value, towards positive infinity. Computes next_up masked (zeroed where mask is false).

fn next_down_c(self, mask: Self::Mask) -> Self

Returns the next representable value less than the current value, towards negative infinity. Computes next_down when mask is true, returns self where false.

fn next_down_m(self, src: Self, mask: Self::Mask) -> Self

Returns the next representable value less than the current value, towards negative infinity. Merges next_down with src using mask.

fn next_down_z(self, mask: Self::Mask) -> Self

Returns the next representable value less than the current value, towards negative infinity. Computes next_down masked (zeroed where mask is false).

fn mul_sign_c(self, mask: Self::Mask, rhs: Self) -> Self

Effectively self * sign.signum(), multiplying the sign bits. Computes mul_sign when mask is true, returns self where false.

fn mul_sign_m(self, src: Self, mask: Self::Mask, rhs: Self) -> Self

Effectively self * sign.signum(), multiplying the sign bits. Merges mul_sign with src using mask.

fn mul_sign_z(self, mask: Self::Mask, rhs: Self) -> Self

Effectively self * sign.signum(), multiplying the sign bits. Computes mul_sign masked (zeroed where mask is false).

fn one_minus_sq(self) -> Self

Computes $1 - x^2$ accurately, avoiding the cancellation a naive 1 - self * self suffers as self approaches ±1 (where the result is small but self * self is near 1).

fn with_bits<const N: usize, K>( _values: [Self; N], _kernel: K, ) -> Option<<K as AsFloatVectorWithBitsKernel<Self, N>>::Output>

where K: AsFloatVectorWithBitsKernel<Self, N>,

Attempt to upcast this FloatVector to a FloatVectorWithBits, using the provided kernel. If not possible, returns None.

impl<V: RealFloatVector> GenericSelectable for Complex<V>

type SelectableMask = <V as GenericSelectable>::SelectableMask

The mask type whose lane count and layout match Self.

fn select<M>(mask: M, t: Self, f: Self) -> Self

where Self::SelectableMask: CastMask<M>,

For each lane, take the value from t where mask is true, otherwise from f.

impl<V: RealFloatVector> GenericVector for Complex<V>

unsafe fn load_unaligned(ptr: *const Self::Element) -> Self

A Complex element is #[repr(C)] over two floats, so one element is load_deinterleaved::<1>, which routes through the inner vector’s register engine and not a lane-by-lane loop.

unsafe fn load_deinterleaved<const M: usize>( ptr: *const Self::Element, ) -> [Self; M]

M interleaved Complex streams are 2 * M interleaved float streams, i.e. a grouped problem with TAIL = 1 (see StreamGroup). M goes straight to the inner vector’s GenericVector::load_deinterleaved_grouped - a NEON LD2/LD4, or a shuffle network on x86 - for any M.

unsafe fn store_interleaved<const M: usize>( ptr: *mut Self::Element, values: [Self; M], )

The exact inverse of load_deinterleaved.

const EMPTY: Self = Self::ZERO

A vector with all elements zeroed.

const LANES: usize = V::LANES

Number of lanes in the vector.

const HAS_NATIVE_ALIGN: bool = V::HAS_NATIVE_ALIGN

Whether align is a native cross-register instruction rather than the generic shuffle-and-blend fallback, forwarded from Register::HAS_NATIVE_ALIGN.

type Element = Complex<<V as GenericVector>::Element>

Scalar element type of the vector.

type Lanes = <V as GenericVector>::Lanes

Number of lanes in the vector, as a typenum.

type Unsigned = <V as GenericVector>::Unsigned

Unsigned Integer Type suitable for use with this vector.

type Signed = <V as GenericVector>::Signed

SignedBits Integer Type suitable for use with this vector.

type Mask = <V as GenericVector>::Mask

Mask type for this vector. Masks are semantically boolean vectors indicating true or false for each lane. They may or may not be represented as actual bits.

fn new<const N: usize>(value: [Self::Element; N]) -> Self

where Const<N>: IntoArrayLength<ArrayLength = Self::Lanes>,

Create a new vector from an array of elements.

fn into_array(self) -> GenericArray<Self::Element, Self::Lanes>

Consume the vector and return its elements as a GenericArray.

fn splat(value: Self::Element) -> Self

Create a new vector from a single element by splatting it across all lanes.

fn single(value: Self::Element) -> Self

Create a new vector with the first lane set to the given value, and all other lanes set to zero.

unsafe fn load(ptr: *const Self::Element) -> Self

Load a vector from an aligned pointer to its elements.

unsafe fn load_streaming(ptr: *const Self::Element) -> Self

Load a vector from a pointer to its elements using non-temporal (streaming) loads.

fn interleave_by<const GROUP: usize>(self, other: Self) -> (Self, Self)

Interleave two vectors at group granularity: blocks of GROUP consecutive elements move as a unit and are never split. GROUP == 1 is interleave; GROUP == 2 is the complex interleave - lo == [a.c0, b.c0, a.c1, b.c1, ...] over the low half of the groups, hi over the high half - which lowers to the doubled-element unpack (unpacklo_pd + permute2f128 on AVX2, zip on NEON) rather than a general permute. The primitive for complex FFT transposes and any group-structured SIMD. GROUP must divide LANES.

fn deinterleave_by<const GROUP: usize>(self, other: Self) -> (Self, Self)

The inverse of interleave_by - group-granularity de-interleave.

fn interleave_radix<const N: usize>(inputs: [Self; N]) -> [Self; N]

Radix-N interleave: the generic sibling of interleave (N == 2). Treats the N inputs as one contiguous N * LANES span and gives out with concat(out)[q * N + r] == inputs[r].extract(q).

fn deinterleave_radix<const N: usize>(inputs: [Self; N]) -> [Self; N]

The inverse of interleave_radix - radix-N de-interleave: out[r].extract(q) == concat(inputs)[q * N + r].

fn deinterleave_radix_by<const N: usize, const GROUP: usize>( inputs: [Self; N], ) -> [Self; N]

Group-granularity radix-N de-interleave: the two-axis unification of deinterleave_radix (GROUP == 1) and deinterleave_by (N == 2). Each vector is viewed as LANES / GROUP groups of GROUP consecutive elements; out[r] group q is the (q * N + r)-th group of the concatenated input sequence, each group moving as a unit.

fn interleave_radix_by<const N: usize, const GROUP: usize>( inputs: [Self; N], ) -> [Self; N]

The inverse of deinterleave_radix_by - group-granularity radix-N interleave. For the square case it is the same (self-inverse) register-array transpose.

unsafe fn load_m(src: Self, mask: Self::Mask, ptr: *const Self::Element) -> Self

Load a vector from an aligned pointer to its elements.

unsafe fn load_z(mask: Self::Mask, ptr: *const Self::Element) -> Self

Load a vector from an aligned pointer to its elements.

unsafe fn store(self, ptr: *mut Self::Element)

Store the vector to an aligned pointer to its elements.

unsafe fn store_unaligned(self, ptr: *mut Self::Element)

Store the vector to an unaligned pointer to its elements.

unsafe fn store_streaming(self, ptr: *mut Self::Element)

Store the vector to a pointer to its elements using non-temporal (streaming) stores.

unsafe fn store_masked(self, mask: Self::Mask, ptr: *mut Self::Element)

Store the vector to an aligned pointer to its elements, but only for lanes where the corresponding mask lane is true. For lanes where the mask is false, the store is suppressed without panicking.

unsafe fn lookup_unchecked( values: &[Self::Element], indices: Self::Unsigned, ) -> Self

Assemble a vector from a slice of elements and a vector of indices into that slice. The indices are NOT checked to be within bounds.

fn broadcast<const I: usize>(self) -> Self

Broadcast the value of a single lane across all lanes of the vector.

fn broadcastv(self, idx: usize) -> Self

Broadcast the value of a single lane across all lanes of the vector.

fn extract<const I: usize>(self) -> Self::Element

Extract a single element from the vector at the const-generic index I.

fn extractv(self, idx: usize) -> Self::Element

Extract a single element from the vector at the runtime index idx.

fn insert<const I: usize>(self, value: Self::Element) -> Self

Replace a single element in the vector at the const-generic index I.

fn insertv(self, idx: usize, value: Self::Element) -> Self

Replace a single element in the vector at the runtime index idx.

fn reverse(self) -> Self

Reverse the order of the elements in the vector.

fn swap_bytes(self) -> Self

Swap the byte order of each element in the vector, converting between little-endian and big-endian representations lane-by-lane.

fn zz(self, mask: Self::Mask) -> Self

(Zero If False) Zero elements if the corresponding mask lane is false; otherwise, leave unchanged.

fn nz(self, mask: Self::Mask) -> Self

(Zero If True) Zero elements if the corresponding mask lane is true; otherwise, leave unchanged.

fn compress(self, mask: Self::Mask) -> Self

Left-pack (a.k.a. compress): gather the lanes where mask is true into the low lanes, preserving their relative order. The unselected lanes are kept (not zeroed) and packed into the high lanes, also in order - a stable partition of the vector by mask.

fn compress_z(self, mask: Self::Mask) -> Self

Zero-filling left-pack: like compress, but the lanes beyond the mask population count are zeroed instead of holding the unselected elements. Matches AVX-512 zero-masking vpcompress*.

fn compress_m(self, src: Self, mask: Self::Mask) -> Self

Merge-masked left-pack: like compress, but the lanes at and beyond the mask population count take their values from src (at their own positions). Matches AVX-512 merge-masked vpcompress*.

fn expand(self, mask: Self::Mask) -> Self

Inverse left-pack (expand): scatter this vector’s packed low lanes back out to the lanes where mask is set, preserving order; the unselected lanes read the tail. The exact inverse permutation of compress: v.compress(m).expand(m) == v and v.expand(m).compress(m) == v for every v and m.

fn expand_z(self, mask: Self::Mask) -> Self

Zero-filling inverse left-pack: like expand, but the unselected lanes are zeroed. Matches AVX-512 zero-masking vpexpand*.

fn expand_m(self, src: Self, mask: Self::Mask) -> Self

Merge-masked inverse left-pack: like expand, but the unselected lanes take their values from src. Matches AVX-512 merge-masked vpexpand*.

fn align<const OFFSET: usize>(self, other: Self) -> Self

Two-register element align (the palignr family): the window of LANES lanes starting at lane OFFSET of the concatenation [self, other] (self’s lanes first, then other’s). OFFSET == 0 returns self, OFFSET == LANES returns other; in between, lanes spill from the tail of self into the head of other.

fn map<F>(self, f: F) -> Self

where F: Fn(Self::Element) -> Self::Element,

Apply a function to each element in the vector, returning a new vector with the results.

fn fold<F>(self, init: Self::Element, f: F) -> Self::Element

where F: Fn(Self::Element, Self::Element) -> Self::Element,

Fold the elements of the vector using the provided function and initial value.

fn reduce<F>(self, f: F) -> Self::Element

where F: Fn(Self::Element, Self::Element) -> Self::Element,

Reduce the elements of the vector using the provided function.

fn splat_m(src: Self, mask: Self::Mask, value: Self::Element) -> Self

Create a new vector from a single element by splatting it across all lanes. Merges splat with src using mask.

fn splat_z(mask: Self::Mask, value: Self::Element) -> Self

Create a new vector from a single element by splatting it across all lanes. Computes splat masked (zeroed where mask is false).

fn broadcast_c<const I: usize>(self, mask: Self::Mask) -> Self

Broadcast the value of a single lane across all lanes of the vector. Computes broadcast when mask is true, returns self where false.

fn broadcast_m<const I: usize>(self, src: Self, mask: Self::Mask) -> Self

Broadcast the value of a single lane across all lanes of the vector. Merges broadcast with src using mask.

fn broadcast_z<const I: usize>(self, mask: Self::Mask) -> Self

Broadcast the value of a single lane across all lanes of the vector. Computes broadcast masked (zeroed where mask is false).

fn broadcastv_c(self, mask: Self::Mask, idx: usize) -> Self

Broadcast the value of a single lane across all lanes of the vector.

fn broadcastv_m(self, src: Self, mask: Self::Mask, idx: usize) -> Self

Broadcast the value of a single lane across all lanes of the vector.

fn broadcastv_z(self, mask: Self::Mask, idx: usize) -> Self

Broadcast the value of a single lane across all lanes of the vector.

fn reverse_c(self, mask: Self::Mask) -> Self

Reverse the order of the elements in the vector.

fn reverse_m(self, src: Self, mask: Self::Mask) -> Self

Reverse the order of the elements in the vector.

fn reverse_z(self, mask: Self::Mask) -> Self

Reverse the order of the elements in the vector.

fn swap_bytes_c(self, mask: Self::Mask) -> Self

Swap the byte order of each element in the vector, converting between little-endian and big-endian representations lane-by-lane.

fn swap_bytes_m(self, src: Self, mask: Self::Mask) -> Self

Swap the byte order of each element in the vector, converting between little-endian and big-endian representations lane-by-lane.

fn swap_bytes_z(self, mask: Self::Mask) -> Self

Swap the byte order of each element in the vector, converting between little-endian and big-endian representations lane-by-lane.

fn lanes() -> usize

Number of lanes in the vector, as a runtime value.

fn concat<INTO>(self, hi: Self) -> INTO

where INTO: ConcatVector<Self, Element = Self::Element>,

Combine two vectors of the same type into one wider vector, with self as the lower half and hi as the upper half.

fn split<INTO>(self) -> (INTO, INTO)

where INTO: GenericVector, Self: ConcatVector<INTO, Element = <INTO as GenericVector>::Element>,

Split this vector into two narrower vectors of the same type, with the lower lanes in the first vector and the upper lanes in the second vector.

fn extend<INTO>(self) -> INTO

where INTO: ExtendVector<Self, Element = Self::Element>,

Zero-extend a narrower vector into this wider vector type, placing the original values in the lower lanes and filling the upper lanes with zeros.

fn narrow<INTO>(self) -> INTO

where INTO: GenericVector, Self: ExtendVector<INTO, Element = <INTO as GenericVector>::Element>,

Narrow this wider vector into a narrower vector by taking the lower lanes.

fn align_slice( slice: &[Self::Element], ) -> (&[Self::Element], &[Self], &[Self::Element])

Align a slice of elements to the vector’s lane count, returning the aligned portion and any unaligned head or tail.

fn align_slice_mut( slice: &mut [Self::Element], ) -> (&mut [Self::Element], &mut [Self], &mut [Self::Element])

Align a mutable slice of elements to the vector’s lane count, returning the aligned portion and any unaligned head or tail.

fn from_slice(slice: &[Self::Element]) -> Self

Create a new vector from a slice of elements. The slice must have at least as many elements as the vector’s lanes.

fn copy_to_slice(self, slice: &mut [Self::Element])

Copy the elements of the vector into a slice. The slice must have at least as many elements as the vector’s lanes.

fn iter_unaligned<'a>( values: &'a [Self::Element], ) -> (Unaligned<'a, Self>, &'a [Self::Element])

Transform a slice of element values into an unaligned iterator of vectors, returning any remaining elements as a suffix slice.

fn iter_mut_unaligned<'a>( values: &'a mut [Self::Element], ) -> (UnalignedMut<'a, Self>, &'a mut [Self::Element])

Transform a mutable slice of element values into an unaligned iterator of vectors, returning any remaining elements as a suffix slice.

fn stream_aligned_slice<'a>( values: &'a [Self::Element], ) -> impl DoubleEndedIterator

Iterate over a slice of element values as Vectors using non-temporal (streaming) loads.

fn stream_aligned_slice_mut<'a>( values: &'a mut [Self::Element], ) -> impl DoubleEndedIterator

Iterate over a mutable slice of element values as Vectors using non-temporal (streaming) loads and stores.

fn gather<I>(slice: &[Self::Element], indices: I) -> Self

where I: VectorIndices<Self>,

Gather elements from memory at the specified indices and return a new vector with those elements.

fn gather_or<I>(slice: &[Self::Element], indices: I, or: Self) -> Self

where I: VectorIndices<Self>, Self::Mask: CastMask<<I as GenericVector>::Mask>,

Gather elements from memory at the specified indices, or return or if the index is out of bounds.

fn gather_or_zero<I>(slice: &[Self::Element], indices: I) -> Self

where I: VectorIndices<Self>, Self::Mask: CastMask<<I as GenericVector>::Mask>,

Gather elements from memory at the specified indices, or set the lane to zero if the index is out of bounds.

fn gather_if<I>( slice: &[Self::Element], enable: Self::Mask, indices: I, or: Self, ) -> Self

where I: VectorIndices<Self>, Self::Mask: CastMask<<I as GenericVector>::Mask>, Self::Element: Default,

Gather elements from memory at the specified indices, or return or if the enable mask is false OR if any index is out of bounds.

fn scatter<I>(self, slice: &mut [Self::Element], indices: I)

where I: VectorIndices<Self>, Self::Mask: CastMask<<I as GenericVector>::Mask>,

Scatter elements from the given vector into memory at the specified indices. If the index is outside of the bounds of the provided slice, the write is suppressed without panicking.

fn scatter_if<I>( self, slice: &mut [Self::Element], enable: Self::Mask, indices: I, )

where I: VectorIndices<Self>, Self::Mask: CastMask<<I as GenericVector>::Mask>,

Scatter elements from the given vector into memory at the specified indices, but only for lanes where the enable mask is true. If the index is outside of the bounds of the provided slice, the write is suppressed without panicking.

unsafe fn load_deinterleaved_arrays<const M: usize, const C: usize>( ptr: *const Self::Element, ) -> [[Self; C]; M]

Load M interleaved AoS records of C components each and de-interleave them: reads M * C * LANES contiguous elements, and out[j][c] holds component c of record j (out[j][c].extract(lane) == ptr[lane * M * C + j * C + c]).

unsafe fn store_interleaved_arrays<const M: usize, const C: usize>( ptr: *mut Self::Element, values: [[Self; C]; M], )

Interleave M records of C components and store them contiguously - the exact inverse of load_deinterleaved_arrays, with the same lane-wise default.

unsafe fn load_deinterleaved_grouped<const M: usize, const TAIL: usize>( ptr: *const Self::Element, ) -> [StreamGroup<Self, TAIL>; M]

Load M interleaved composite streams of 1 + TAIL components each and de-interleave them into M StreamGroups: reads M * (TAIL + 1) * LANES contiguous elements, and group j’s head/tail[c - 1] hold the de-interleaved components of composite stream j. See StreamGroup for why the component count is a separate const generic, and Register::load_deinterleaved_grouped for the register-level strategy.

unsafe fn store_interleaved_grouped<const M: usize, const TAIL: usize>( ptr: *mut Self::Element, values: [StreamGroup<Self, TAIL>; M], )

Interleave M StreamGroups and store them as a contiguous array-of-structures - the exact inverse of load_deinterleaved_grouped, with the same lane-wise default and the same override expectations.

fn lookup(values: &[Self::Element], indices: Self::Unsigned) -> Self

Assemble a vector from a slice of elements and a vector of indices into that slice. If an index is outside the bounds of the given slice, the resulting lane will be the first element of the input slice.

fn first(self) -> Self::Element

Extract lane 0 – the scalar counterpart to single.

fn prefix_mask(n: usize) -> Self::Mask

Construct a mask whose first n lanes are true and the remaining lanes false.

fn suffix_mask(n: usize) -> Self::Mask

Construct a mask whose last n lanes are true and the remaining lanes false.

fn cast<INTO>(self) -> INTO

where INTO: CastVector<Self>,

Numeric cast to another vector type, matching the semantics of Rust’s as operator on the underlying scalar elements for in-range, finite inputs.

fn fast_cast<INTO>(self) -> INTO

where INTO: CastVector<Self>,

Fast numeric cast to another vector type.

fn into_bits<INTO>(self) -> INTO

where INTO: BitCastVector<Self>,

Reinterpret the bits of this vector as another vector type of the same size and lane count.

fn saturating_cast<INTO>(self) -> INTO

where INTO: CastVector<Self>,

Cast that saturates (clamps) out-of-range values to the destination element range, rather than wrapping (integers) or producing a backend-defined value (float-to-int) like cast.

impl<V: HasIsa> HasIsa for Complex<V>

const ISA: InstructionSet = V::ISA

The instruction set this backend implements.

type Native = <V as HasIsa>::Native

The backend this type executes on.

impl<V: RealFloatVector> Interleave for Complex<V>

fn interleave(self, other: Self) -> (Self, Self)

Unpack and interleave elements from two vectors.

fn deinterleave(self, other: Self) -> (Self, Self)

Pack and deinterleave elements from two vectors. This is the inverse operation of interleave.

impl<V: RealValue> Mul for Complex<V>

type Output = Complex<V>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<V: RealValue> Mul<V> for Complex<V>

type Output = Complex<V>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<V: RealValue, A, B> MulAddAssignExt<A, B> for Complex<V>

where Self: MulAddExt<A, B, Output = Self>,

fn mul_add_assign(&mut self, a: A, b: B)

Guaranteed fused-multiply-add operation.

fn mul_sub_assign(&mut self, a: A, b: B)

Guaranteed fused-multiply-subtract operation.

fn nmul_add_assign(&mut self, a: A, b: B)

Guaranteed fused-negated-multiply-add operation.

fn nmul_sub_assign(&mut self, a: A, b: B)

Guaranteed fused-negated-multiply-subtract operation.

fn mul_adde_assign(&mut self, a: A, b: B)

Fused-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn mul_sube_assign(&mut self, a: A, b: B)

Fused-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn nmul_adde_assign(&mut self, a: A, b: B)

Fused-negated-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn nmul_sube_assign(&mut self, a: A, b: B)

Fused-negated-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

impl<V: RealFloatVector, A, B> MulAddAssignExtMasked<<V as GenericVector>::Mask, A, B> for Complex<V>

where Complex<V>: MulAddExt<A, B, Output = Self>,

fn mul_add_assign_c(&mut self, mask: V::Mask, a: A, b: B)

Guaranteed fused-multiply-add operation.

fn mul_add_assign_m(&mut self, src: Self, mask: V::Mask, a: A, b: B)

Guaranteed fused-multiply-add operation.

fn mul_add_assign_z(&mut self, mask: V::Mask, a: A, b: B)

Guaranteed fused-multiply-add operation.

fn mul_sub_assign_c(&mut self, mask: V::Mask, a: A, b: B)

Guaranteed fused-multiply-subtract operation.

fn mul_sub_assign_m(&mut self, src: Self, mask: V::Mask, a: A, b: B)

Guaranteed fused-multiply-subtract operation.

fn mul_sub_assign_z(&mut self, mask: V::Mask, a: A, b: B)

Guaranteed fused-multiply-subtract operation.

fn nmul_add_assign_c(&mut self, mask: V::Mask, a: A, b: B)

Guaranteed fused-negated-multiply-add operation.

fn nmul_add_assign_m(&mut self, src: Self, mask: V::Mask, a: A, b: B)

Guaranteed fused-negated-multiply-add operation.

fn nmul_add_assign_z(&mut self, mask: V::Mask, a: A, b: B)

Guaranteed fused-negated-multiply-add operation.

fn nmul_sub_assign_c(&mut self, mask: V::Mask, a: A, b: B)

Guaranteed fused-negated-multiply-subtract operation.

fn nmul_sub_assign_m(&mut self, src: Self, mask: V::Mask, a: A, b: B)

Guaranteed fused-negated-multiply-subtract operation.

fn nmul_sub_assign_z(&mut self, mask: V::Mask, a: A, b: B)

Guaranteed fused-negated-multiply-subtract operation.

fn mul_adde_assign_c(&mut self, mask: V::Mask, a: A, b: B)

Fused-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn mul_adde_assign_m(&mut self, src: Self, mask: V::Mask, a: A, b: B)

Fused-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn mul_adde_assign_z(&mut self, mask: V::Mask, a: A, b: B)

Fused-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn mul_sube_assign_c(&mut self, mask: V::Mask, a: A, b: B)

Fused-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn mul_sube_assign_m(&mut self, src: Self, mask: V::Mask, a: A, b: B)

Fused-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn mul_sube_assign_z(&mut self, mask: V::Mask, a: A, b: B)

Fused-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn nmul_adde_assign_c(&mut self, mask: V::Mask, a: A, b: B)

Fused-negated-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn nmul_adde_assign_m(&mut self, src: Self, mask: V::Mask, a: A, b: B)

Fused-negated-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn nmul_adde_assign_z(&mut self, mask: V::Mask, a: A, b: B)

Fused-negated-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn nmul_sube_assign_c(&mut self, mask: V::Mask, a: A, b: B)

Fused-negated-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn nmul_sube_assign_m(&mut self, src: Self, mask: V::Mask, a: A, b: B)

Fused-negated-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn nmul_sube_assign_z(&mut self, mask: V::Mask, a: A, b: B)

Fused-negated-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

impl<V: RealValue> MulAddExt for Complex<V>

const HAS_TRUE_FMA: bool = false

Indicates whether the implementation uses true fused-multiply-add instructions.

type Output = Complex<V>

The result of the fused operation.

fn mul_add(self, a: Self, b: Self) -> Self

Guaranteed fused-multiply-add operation.

fn mul_sub(self, a: Self, b: Self) -> Self

Guaranteed fused-multiply-subtract operation.

fn nmul_add(self, a: Self, b: Self) -> Self

Guaranteed fused-negated-multiply-add operation.

fn nmul_sub(self, a: Self, b: Self) -> Self

Guaranteed fused-negated-multiply-subtract operation.

fn mul_adde(self, a: Self, b: Self) -> Self

Fused-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn mul_sube(self, a: Self, b: Self) -> Self

Fused-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn nmul_adde(self, a: Self, b: Self) -> Self

Fused-negated-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn nmul_sube(self, a: Self, b: Self) -> Self

Fused-negated-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

impl<V: RealValue> MulAddExt<V> for Complex<V>

const HAS_TRUE_FMA: bool

Indicates whether the implementation uses true fused-multiply-add instructions.

type Output = Complex<V>

The result of the fused operation.

fn mul_add(self, a: V, b: Self) -> Self

Guaranteed fused-multiply-add operation.

fn mul_sub(self, a: V, b: Self) -> Self

Guaranteed fused-multiply-subtract operation.

fn nmul_add(self, a: V, b: Self) -> Self

Guaranteed fused-negated-multiply-add operation.

fn nmul_sub(self, a: V, b: Self) -> Self

Guaranteed fused-negated-multiply-subtract operation.

fn mul_adde(self, a: V, b: Self) -> Self

Fused-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn mul_sube(self, a: V, b: Self) -> Self

Fused-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn nmul_adde(self, a: V, b: Self) -> Self

Fused-negated-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn nmul_sube(self, a: V, b: Self) -> Self

Fused-negated-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

impl<V: RealFloatVector, A, B> MulAddExtMasked<<V as GenericVector>::Mask, A, B> for Complex<V>

where Complex<V>: MulAddExt<A, B, Output = Self>,

fn mul_add_c(self, mask: V::Mask, a: A, b: B) -> Self

Guaranteed fused-multiply-add operation.

fn mul_add_m(self, src: Self, mask: V::Mask, a: A, b: B) -> Self

Guaranteed fused-multiply-add operation.

fn mul_add_z(self, mask: V::Mask, a: A, b: B) -> Self

Guaranteed fused-multiply-add operation.

fn mul_sub_c(self, mask: V::Mask, a: A, b: B) -> Self

Guaranteed fused-multiply-subtract operation.

fn mul_sub_m(self, src: Self, mask: V::Mask, a: A, b: B) -> Self

Guaranteed fused-multiply-subtract operation.

fn mul_sub_z(self, mask: V::Mask, a: A, b: B) -> Self

Guaranteed fused-multiply-subtract operation.

fn nmul_add_c(self, mask: V::Mask, a: A, b: B) -> Self

Guaranteed fused-negated-multiply-add operation.

fn nmul_add_m(self, src: Self, mask: V::Mask, a: A, b: B) -> Self

Guaranteed fused-negated-multiply-add operation.

fn nmul_add_z(self, mask: V::Mask, a: A, b: B) -> Self

Guaranteed fused-negated-multiply-add operation.

fn nmul_sub_c(self, mask: V::Mask, a: A, b: B) -> Self

Guaranteed fused-negated-multiply-subtract operation.

fn nmul_sub_m(self, src: Self, mask: V::Mask, a: A, b: B) -> Self

Guaranteed fused-negated-multiply-subtract operation.

fn nmul_sub_z(self, mask: V::Mask, a: A, b: B) -> Self

Guaranteed fused-negated-multiply-subtract operation.

fn mul_adde_c(self, mask: V::Mask, a: A, b: B) -> Self

Fused-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn mul_adde_m(self, src: Self, mask: V::Mask, a: A, b: B) -> Self

Fused-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn mul_adde_z(self, mask: V::Mask, a: A, b: B) -> Self

Fused-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn mul_sube_c(self, mask: V::Mask, a: A, b: B) -> Self

Fused-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn mul_sube_m(self, src: Self, mask: V::Mask, a: A, b: B) -> Self

Fused-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn mul_sube_z(self, mask: V::Mask, a: A, b: B) -> Self

Fused-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn nmul_adde_c(self, mask: V::Mask, a: A, b: B) -> Self

Fused-negated-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn nmul_adde_m(self, src: Self, mask: V::Mask, a: A, b: B) -> Self

Fused-negated-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn nmul_adde_z(self, mask: V::Mask, a: A, b: B) -> Self

Fused-negated-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn nmul_sube_c(self, mask: V::Mask, a: A, b: B) -> Self

Fused-negated-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn nmul_sube_m(self, src: Self, mask: V::Mask, a: A, b: B) -> Self

Fused-negated-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn nmul_sube_z(self, mask: V::Mask, a: A, b: B) -> Self

Fused-negated-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

impl<V: RealValue, T> MulAssign<T> for Complex<V>

where Self: Mul<T, Output = Self>,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<V: RealFloatVector, Rhs> MulAssignMasked<<V as GenericVector>::Mask, Rhs> for Complex<V>

where Complex<V>: Mul<Rhs, Output = Self>,

fn mul_assign_c(&mut self, mask: V::Mask, rhs: Rhs)

Computes MulAssign with rhs where mask is true.

fn mul_assign_m(&mut self, src: Self, mask: V::Mask, rhs: Rhs)

Merges MulAssign with src using mask, assigning src where mask is false.

fn mul_assign_z(&mut self, mask: V::Mask, rhs: Rhs)

Computes MulAssign masked (zeroed where mask is false).

impl<V: RealFloatVector, Rhs> MulMasked<<V as GenericVector>::Mask, Rhs> for Complex<V>

where Complex<V>: Mul<Rhs, Output = Self>,

fn mul_c(self, mask: V::Mask, rhs: Rhs) -> Self

Computes Mul with rhs where mask is true.

fn mul_m(self, src: Self, mask: V::Mask, rhs: Rhs) -> Self

Merges Mul with src using mask, returning src where mask is false.

fn mul_z(self, mask: V::Mask, rhs: Rhs) -> Self

Computes Mul masked (zeroed where mask is false).

impl<V: RealValue> Neg for Complex<V>

type Output = Complex<V>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<V: RealFloatVector> NegMasked<<V as GenericVector>::Mask> for Complex<V>

fn neg_c(self, mask: V::Mask) -> Self

Computes Neg where mask is true, does nothing where false.

fn neg_m(self, src: Self, mask: V::Mask) -> Self

Merges Neg with src using mask, returning src where mask is false.

fn neg_z(self, mask: V::Mask) -> Self

Computes Neg masked (zeroed where mask is false).

impl<V: RealFloatVector> NewVector<Complex<<V as GenericVector>::Element>, <V as GenericVector>::Lanes> for Complex<V>

type New<T: NewConst<Complex<V::Element>, V::Lanes>> = ComplexNewImpl

For a given array carrier T, the type exposing the constructed vector constant via VectorValue.

impl<V: RealFloatVector> NumericVector for Complex<V>

const ZERO: Self

A vector of the value “0” in the element type.

const ONE: Self

A vector of the value “1” in the element type.

const TWO: Self

A vector of the value “2” in the element type.

const MIN: Self

A vector of the minimum value the element type of this vector can represent.

const MAX: Self

A vector of the maximum value the element type of this vector can represent.

fn to_signed_integer(self) -> Self::Signed

Convert each lane to the companion signed integer type, with as semantics - round toward zero, saturating at the bounds, NaN to zero.

fn from_signed_integer(v: Self::Signed) -> Self

Convert each lane from the companion signed integer type, with as semantics.

fn to_unsigned_integer(self) -> Self::Unsigned

Convert each lane to the companion unsigned integer type, with as semantics. See to_signed_integer.

fn from_unsigned_integer(v: Self::Unsigned) -> Self

Convert each lane from the companion unsigned integer type, with as semantics. See from_signed_integer.

fn is_zero(self) -> Self::Mask

For each element in the vector, return a mask indicating whether that element is zero.

fn is_all_zero(self) -> bool

Returns true if all elements in the vector are zero, false otherwise.

fn sort_by<O: SortOrder>(self) -> Self

Sort the lanes of this vector in O order.

fn bitonic_clean_by<O: SortOrder>(self) -> Self

Sort the lanes of a bitonic vector in O order - one that rises then falls, or a rotation of one.

fn min(self, other: Self) -> Self

Return the minimum of two vectors, element-wise.

fn max(self, other: Self) -> Self

Return the maximum of two vectors, element-wise.

fn clamp(self, min: Self, max: Self) -> Self

Clamps the elements of the vector between the given minimum and maximum values.

fn min_element(self) -> Self::Element

Returns the minimum value in the vector.

fn max_element(self) -> Self::Element

Returns the maximum value in the vector.

fn min_max_element(self) -> (Self::Element, Self::Element)

Returns both the minimum and maximum values in the vector simultaneously.

fn arg_minmax(self) -> (usize, usize)

Returns the indices of the minimum and maximum elements in the vector, respectively.

fn sum_elements(self) -> Self::Element

Returns the sum of all elements in the vector.

fn prefix_sum(self) -> Self

Inclusive forward prefix sum (“running total”): out[i] = self[0] + .. + self[i].

fn reverse_prefix_sum(self) -> Self

Inclusive reverse (suffix) sum: out[i] = self[i] + .. + self[LANES-1].

fn prefix_min(self) -> Self

Inclusive forward prefix minimum: out[i] = min(self[0], .., self[i]).

fn prefix_max(self) -> Self

Inclusive forward prefix maximum: out[i] = max(self[0], .., self[i]).

fn reverse_prefix_min(self) -> Self

Inclusive reverse (suffix) minimum: out[i] = min(self[i], .., self[LANES-1]).

fn reverse_prefix_max(self) -> Self

Inclusive reverse (suffix) maximum: out[i] = max(self[i], .., self[LANES-1]).

fn prod_elements(self) -> Self::Element

Returns the product of all elements in the vector.

fn offset() -> Self

Returns a vector whose every lane equals LANES, converted into the element type.

fn indexed() -> Self

Returns a vector where each lane holds its own index, cast to the element type: [0, 1, 2, ..., LANES-1].

fn scale(self, factor: Self::Element) -> Self

Scales each element in the vector by the given factor.

fn scale_c(self, mask: Self::Mask, factor: Self::Element) -> Self

Scales each element in the vector by the given factor.

fn scale_m(self, src: Self, mask: Self::Mask, factor: Self::Element) -> Self

Scales each element in the vector by the given factor.

fn scale_z(self, mask: Self::Mask, factor: Self::Element) -> Self

Scales each element in the vector by the given factor.

fn min_c(self, mask: Self::Mask, rhs: Self) -> Self

Return the minimum of two vectors, element-wise. Computes min when mask is true, returns self where false.

fn min_m(self, src: Self, mask: Self::Mask, rhs: Self) -> Self

Return the minimum of two vectors, element-wise. Merges min with src using mask.

fn min_z(self, mask: Self::Mask, rhs: Self) -> Self

Return the minimum of two vectors, element-wise. Computes min masked (zeroed where mask is false).

fn max_c(self, mask: Self::Mask, rhs: Self) -> Self

Return the maximum of two vectors, element-wise. Computes max when mask is true, returns self where false.

fn max_m(self, src: Self, mask: Self::Mask, rhs: Self) -> Self

Return the maximum of two vectors, element-wise. Merges max with src using mask.

fn max_z(self, mask: Self::Mask, rhs: Self) -> Self

Return the maximum of two vectors, element-wise. Computes max masked (zeroed where mask is false).

fn pairwise_sum(lo: Self, hi: Self) -> Self

Sums adjacent lane pairs from lo and hi, returning a vector of the same width.

fn relaxed_pairwise_sum(lo: Self, hi: Self) -> Self

Like pairwise_sum, but may return a relaxed (implementation-defined) lane ordering for performance. Treat this as if randomly shuffling the result of pairwise_sum, with better performance than pairwise_sum.

fn fast_to_signed_integer(self) -> Self::Signed

Like to_signed_integer, but may relax IEEE corner cases (out-of-range and NaN inputs) for speed. Defaults to the exact form.

fn fast_to_unsigned_integer(self) -> Self::Unsigned

Like to_unsigned_integer, but may relax IEEE corner cases. Defaults to the exact form.

fn sort(self) -> Self

Sort the lanes ascending. Shorthand for sort_by::<Ascending>.

fn bitonic_clean(self) -> Self

Sort the lanes of a bitonic vector ascending. Shorthand for bitonic_clean_by::<Ascending>.

impl<V: PartialEq> PartialEq for Complex<V>

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

Equality operator ==.

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

Inequality operator !=.

impl<V: PartialOrd> PartialOrd for Complex<V>

fn partial_cmp(&self, other: &Complex<V>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<V: RealFloatVector> PartialOrdVector for Complex<V>

fn cmp_eq(self, other: Self) -> Self::Mask

Lane-wise self == other.

fn cmp_ne(self, other: Self) -> Self::Mask

Lane-wise self != other.

fn cmp_lt(self, other: Self) -> Self::Mask

Lane-wise self < other.

fn cmp_gt(self, other: Self) -> Self::Mask

Lane-wise self > other.

fn cmp_le(self, other: Self) -> Self::Mask

Lane-wise self <= other.

fn cmp_ge(self, other: Self) -> Self::Mask

Lane-wise self >= other.

fn group_by_value(self, valid: Self::Mask) -> ValueGroups<Self>

Partition the lanes selected by valid into groups of equal value.

impl<V: RealValue> Product for Complex<V>

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<V: RealValue> Rem for Complex<V>

type Output = Complex<V>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<V: RealValue> Rem<V> for Complex<V>

type Output = Complex<V>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<V: RealValue, T> RemAssign<T> for Complex<V>

where Self: Rem<T, Output = Self>,

fn rem_assign(&mut self, rhs: T)

Performs the %= operation.

impl<V: RealFloatVector, Rhs> RemAssignMasked<<V as GenericVector>::Mask, Rhs> for Complex<V>

where Complex<V>: Rem<Rhs, Output = Self>,

fn rem_assign_c(&mut self, mask: V::Mask, rhs: Rhs)

Computes RemAssign with rhs where mask is true.

fn rem_assign_m(&mut self, src: Self, mask: V::Mask, rhs: Rhs)

Merges RemAssign with src using mask, assigning src where mask is false.

fn rem_assign_z(&mut self, mask: V::Mask, rhs: Rhs)

Computes RemAssign masked (zeroed where mask is false).

impl<V: RealFloatVector, Rhs> RemMasked<<V as GenericVector>::Mask, Rhs> for Complex<V>

where Complex<V>: Rem<Rhs, Output = Self>,

fn rem_c(self, mask: V::Mask, rhs: Rhs) -> Self

Computes Rem with rhs where mask is true.

fn rem_m(self, src: Self, mask: V::Mask, rhs: Rhs) -> Self

Merges Rem with src using mask, returning src where mask is false.

fn rem_z(self, mask: V::Mask, rhs: Rhs) -> Self

Computes Rem masked (zeroed where mask is false).

impl<E: RealValue + FloatElement> SignedElement for Complex<E>

fn abs(self) -> Self

The modulus $|z|$, as a real complex number.

fn signum(self) -> Self

$z/|z|$, the unit complex number along z, and zero at the origin.

impl<V: RealFloatVector> SignedVector for Complex<V>

fn abs(self) -> Self

The modulus $|z|$, as a real complex number.

fn signum(self) -> Self

$z/|z|$, the unit complex number along z, and zero at the origin.

Preserves the real identity abs(z) * signum(z) == z.

const NEG_ONE: Self

A vector of the value “-1” in the element type.

const MIN_POSITIVE: Self

A vector of the smallest positive (non-zero) value in the element type.

fn is_positive(self) -> Self::Mask

For each element in the vector, return a mask indicating whether that element is negative.

fn is_negative(self) -> Self::Mask

For each element in the vector, return a mask indicating whether that element is positive.

fn select_negative(self, if_neg: Self, if_pos: Self) -> Self

Based on if self is negative, select between if_neg and if_pos.

fn copysign(self, sign: Self) -> Self

For each element in the vector, set the sign of that element to the sign of the corresponding element in the other vector.

fn abs_c(self, mask: Self::Mask) -> Self

Take the absolute value of the vector, element-wise. Computes abs when mask is true, returns self where false.

fn abs_m(self, src: Self, mask: Self::Mask) -> Self

Take the absolute value of the vector, element-wise. Merges abs with src using mask.

fn abs_z(self, mask: Self::Mask) -> Self

Take the absolute value of the vector, element-wise. Computes abs masked (zeroed where mask is false).

fn copysign_c(self, mask: Self::Mask, rhs: Self) -> Self

For each element in the vector, set the sign of that element to the sign of the corresponding element in the other vector. Computes copysign when mask is true, returns self where false.

fn copysign_m(self, src: Self, mask: Self::Mask, rhs: Self) -> Self

For each element in the vector, set the sign of that element to the sign of the corresponding element in the other vector. Merges copysign with src using mask.

fn copysign_z(self, mask: Self::Mask, rhs: Self) -> Self

For each element in the vector, set the sign of that element to the sign of the corresponding element in the other vector. Computes copysign masked (zeroed where mask is false).

impl<V: RealFloatVector> SortKey<Complex<V>> for Complex<V>

The lane-sort key: strictly-before under the lexicographic (re, im) order, i.e. cmp_lt. See thermite::sort::SortKey for why this is a static trait method and not a closure.

fn key_lt(a: Self, b: Self) -> V::Mask

Which lanes of a sort strictly before those of b, by the key.

impl<V: RealFloatVector> SpecializedComplexMath<Complex<<V as GenericVector>::Element>> for Complex<V>

fn norm<P: Policy>(self) -> V

The modulus (magnitude) |z|.

fn arg<P: Policy>(self) -> V

The principal argument arg(z), in (-pi, pi].

fn from_polar<P: Policy>(r: V, theta: V) -> Self

Builds a complex number from a polar representation r * exp(i*theta).

fn powfr<P: Policy>(self, e: V) -> Self

Raises self to a real power.

fn expf<P: Policy>(self, base: V) -> Self

Raises a real base to the complex power self.

fn logr<P: Policy>(self, base: V) -> Self

The logarithm of self in an arbitrary real base.

fn finv<P: Policy>(self) -> Self

1/self, scaling by the modulus and not its square.

fn to_polar<P: Policy>(self) -> (Self::Real, Self::Real)

Polar form (r, theta), such that self == r * exp(i*theta).

fn fdiv<P: Policy>(self, rhs: Self) -> Self

self/rhs, scaling by the modulus and not its square.

impl<E, V: FloatVector<Element = E>, const N: usize> SpecializedComplexSpecialMath<Complex<Dual<E, N>>> for Complex<Dual<V, N>>

where E: FloatElementWithBits + DualValue, Dual<V, N>: RealFloatVector<Element = Dual<E, N>>,

Available on crate features dual and special only.

fn complex_trigamma<P: Policy>(self) -> Self

The shared body is already generic over RealValue, so it differentiates itself; all Dual has to supply is the same table with zero derivative parts, which is what Dual::constant means.

This is psi_2 by forward-mode AD, without a tetragamma ever being written.

fn complex_tgamma<P: Policy>(self) -> Self

fn complex_lgamma<P: Policy>(self) -> Self

fn complex_digamma<P: Policy>(self) -> Self

fn complex_lambert_w<P: Policy>(self) -> (Self, Self)

fn faddeeva_w<P: Policy>(self) -> Self

The Faddeeva function $w(z) = e^{-z^2}\operatorname{erfc}(-iz)$.

fn erfcx<P: Policy>(self) -> Self

$\operatorname{erfcx}(z) = e^{z^2}\operatorname{erfc}(z) = w(iz)$.

fn voigt<P: Policy>(self) -> Self::Real

The Voigt function $K(x, y) = \operatorname{Re} w(x + iy)$, the convolution of a Gaussian and a Lorentzian in normalized coordinates, as a real value.

fn complex_beta<P: Policy>(self, b: Self) -> Self

$B(a, b) = \frac{\Gamma(a)\Gamma(b)}{\Gamma(a+b)}$

impl<V: RealFloatVector<Element = f32>> SpecializedComplexSpecialMath<Complex<f32>> for Complex<V>

Available on crate feature special only.

fn complex_tgamma<P: Policy>(self) -> Self

fn complex_lgamma<P: Policy>(self) -> Self

fn complex_digamma<P: Policy>(self) -> Self

fn complex_trigamma<P: Policy>(self) -> Self

fn complex_lambert_w<P: Policy>(self) -> (Self, Self)

fn faddeeva_w<P: Policy>(self) -> Self

The Faddeeva function $w(z) = e^{-z^2}\operatorname{erfc}(-iz)$.

fn erfcx<P: Policy>(self) -> Self

$\operatorname{erfcx}(z) = e^{z^2}\operatorname{erfc}(z) = w(iz)$.

fn voigt<P: Policy>(self) -> Self::Real

The Voigt function $K(x, y) = \operatorname{Re} w(x + iy)$, the convolution of a Gaussian and a Lorentzian in normalized coordinates, as a real value.

fn complex_beta<P: Policy>(self, b: Self) -> Self

$B(a, b) = \frac{\Gamma(a)\Gamma(b)}{\Gamma(a+b)}$

impl<V: RealFloatVector<Element = f64>> SpecializedComplexSpecialMath<Complex<f64>> for Complex<V>

Available on crate feature special only.

fn complex_tgamma<P: Policy>(self) -> Self

fn complex_lgamma<P: Policy>(self) -> Self

fn complex_digamma<P: Policy>(self) -> Self

fn complex_trigamma<P: Policy>(self) -> Self

fn complex_lambert_w<P: Policy>(self) -> (Self, Self)

fn faddeeva_w<P: Policy>(self) -> Self

The Faddeeva function $w(z) = e^{-z^2}\operatorname{erfc}(-iz)$.

fn erfcx<P: Policy>(self) -> Self

$\operatorname{erfcx}(z) = e^{z^2}\operatorname{erfc}(z) = w(iz)$.

fn voigt<P: Policy>(self) -> Self::Real

The Voigt function $K(x, y) = \operatorname{Re} w(x + iy)$, the convolution of a Gaussian and a Lorentzian in normalized coordinates, as a real value.

fn complex_beta<P: Policy>(self, b: Self) -> Self

$B(a, b) = \frac{\Gamma(a)\Gamma(b)}{\Gamma(a+b)}$

impl<V: RealFloatVector> SpecializedCoreMath<Complex<<V as GenericVector>::Element>> for Complex<V>

fn poly_rational<P: Policy, const N: usize, const D: usize>( self, numerator: &[Complex<V::Element>; N], denominator: &[Complex<V::Element>; D], ) -> Self

P(z)/Q(z), evaluated directly or through 1/z depending on which is better conditioned.

Overridden only to change which quantity that decision is made on. The generic default tests x.cmp_gt(ONE), which over C is the lexicographic order on (re, im) - so it keys off the real part alone and will happily evaluate the direct form at z = 10^150 i, overflowing, while reporting that z is “not greater than one”. The condition that actually matters is |z| > 1.

Both forms are the same rational function (P_rev(1/z)/Q_rev(1/z) differs from P(z)/Q(z) only by z^(D-N), corrected below), so this is a conditioning fix, not a correctness one - except where the wrong choice overflows outright.

fn inverse_sqrt<P: Policy>(self) -> Self

fn poly<P, const N: usize>(self, coeffs: &[E; N]) -> Self

where P: Policy,

fn poly_rev<P, const N: usize>(self, coeffs: &[E; N]) -> Self

where P: Policy,

fn reciprocal<P>(self) -> Self

where P: Policy,

fn approx_div<P>(self, rhs: Self) -> Self

where P: Policy,

fn reciprocal_adde<P>(self, a: Self) -> Self

where P: Policy,

fn powi<P>(self, e: i32) -> Self

where P: Policy,

fn powic<P, const N: i32>(self) -> Self

where P: Policy,

fn powiv<P>(self, e: Self::Signed) -> Self

where P: Policy,

impl<V: RealFloatVector> SpecializedSpatialMath<Complex<<V as GenericVector>::Element>> for Complex<V>

fn hypot_n<P: Policy, const N: usize>(values: [Self; N]) -> Self

$\sqrt{\sum_i |z_i|^2}$, as a real complex number.

Must be overridden, and not only for tuning. The generic hypot_n changes meaning over C depending on the precision policy: its high-precision path opens with abs(), which here is the modulus, so everything after it is real and the result is the norm - but the PrecisionPolicy::Worst path skips that and squares directly, giving the analytic continuation sqrt(sum z_i^2) instead. Two different functions behind one name, chosen by a policy.

This pins the norm, matching l2_norm and the crate docs. Taking the modulus of each term first costs N extra square roots and buys the same overflow safety the real hypot_n has.

fn inv_hypot_n<P: Policy, const N: usize>(values: [Self; N]) -> Self

$1/\sqrt{\sum_i |z_i|^2}$, as a real complex number. See hypot_n.

fn l1_norm<P: Policy>(self) -> Self

|re| + |im|, as a real complex number.

fn l2_norm_squared<P: Policy>(self) -> Self

$|z|^2 = z\bar{z}$, as a real complex number.

fn l2_norm<P: Policy>(self) -> Self

The modulus $|z|$, as a real complex number.

The default sqrt(l2_norm_squared()) squares the range and overflows for large components; hypot does not.

fn hypot<P>(self, y: Self) -> Self

where P: Policy,

impl<E, V: RealFloatVector<Element = E>> SpecializedSpecialMath<Complex<E>> for Complex<V>

where Complex<V>: SpecializedComplexSpecialMath<Complex<E>> + GenericVector<Mask = V::Mask>,

Available on crate feature special only.

fn erf<P: Policy>(self) -> Self

The error function over the whole complex plane.

erf is entire and odd. The negative-real half-plane comes from erf(-z) = -erf(z), a conditional negation, not a branch.

fn erfc<P: Policy>(self) -> Self

The complementary error function over the whole complex plane.

The 1 - erf(z) default cancels for large Re z, where erfc is the function one wants in the first place; the continued fraction computes it directly there. The negative half-plane uses erfc(z) = 2 - erfc(-z).

fn logistic_sigmoid<P: Policy>(self) -> Self

$\sigma(z) = \frac{1}{1 + e^{-z}}$

The default stabilizes for the real axis by negating on is_positive() and selecting, neither of which is holomorphic. The plain definition is, and the default itself falls back to it at lower precision policies.

fn softplus<P: Policy>(self, k: Self, rcp_k: Self) -> Self

$\frac{1}{k}\ln(1 + e^{kz})$

The default’s max(x, 0) + ln1p(e^{-|kx|}) is the real-axis overflow-stable rearrangement, and neither |x| nor max is holomorphic. This uses the analytic definition, and so overflows for large Re(kz) where the real form would not.

fn lambert_w<P: Policy>(self) -> (Self, Self)

Both $W_0$ and $W_{-1}$ are genuine branches of the complex Lambert W, so the real signature carries over unchanged - it simply cannot reach $W_k$ for $|k| \ge 2$.

type ExpIntDetails = Complex<V>

Per-arithmetic details of the expint kernel. Almost always Self, with an empty ExpIntDetails impl taking every default.

fn tgamma<P: Policy>(self) -> Self

fn lgamma<P: Policy>(self) -> Self

fn digamma<P: Policy>(self) -> Self

fn trigamma<P: Policy>(self) -> Self

The trigamma function psi_1(x) = d/dx psi(x), the second derivative of ln Gamma.

fn beta<P: Policy>(a: Self, b: Self) -> Self

fn expint<P, const N: usize>(self) -> Self

where P: Policy,

Computes the exponential integral E_N(x) for integer order N.

fn expint_primal<P, const N: usize>(self) -> (Self, Self)

where P: Policy,

Computes $E_N(x)$ together with the adjacent lower order $E_{N-1}(x)$.

fn hermite<P, const N: usize>(x: Self) -> Self

where P: Policy,

fn hermitev<P>(x: Self, n: Self::Unsigned) -> Self

where P: Policy,

fn chebyshev<P, const K: usize, const N: usize>( self, coeffs: &[Self::Element; N], ) -> Self

where P: Policy,

fn jacobi<P>(x: Self, alpha: Self, beta: Self, n: u32, m: u32) -> Self

where P: Policy,

fn gaussian<P>(x: Self, a: Self, c: Self) -> Self

where P: Policy,

fn legendre0<P, const N: u32>(x: Self, n: u32) -> Self

where P: Policy,

fn legendre<P>(x: Self, n: u32, m: u32) -> Self

where P: Policy,

impl<V: RealFloatVector> SpecializedTranscendentalMath<Complex<<V as GenericVector>::Element>> for Complex<V>

fn sin_cos<P: Policy>(self) -> (Self, Self)

sin(a + bi) = sin(a)cosh(b) + i*cos(a)sinh(b), cos(a + bi) = cos(a)cosh(b) - i*sin(a)sinh(b).

fn sincos_pi<P: Policy>(self) -> (Self, Self)

$\sin(\pi z)$ and $\cos(\pi z)$, from the real sincos_pi.

Must be overridden rather than left to the default. That default is sin_cos(z * pi), which rounds pi * Re z before doing any reduction and so throws away the exact argument reduction real sincos_pi performs near the integers - precisely where the Gamma reflection formulas put their poles, and where sin(pi z) passes through zero. It is also no more work: one real sincos_pi and one real sinh_cosh, the same two calls the default makes.

fn tan<P: Policy>(self) -> Self

$\tan(a + bi) = \frac{\sin 2a + i\sinh 2b}{\cos 2a + \cosh 2b}$

The doubled-angle form takes one real division, where the default (sin_cos then a complex divide) takes a complex one.

Under check_overflow the saturation is handled: $\tan(z) \to i\,\mathrm{sign}(b)$ as $|b|$ grows, but $\sinh$ and $\cosh$ both overflow past $|2b| \approx 710$ and the quotient becomes inf/inf. tan(1 + 400i) was NaN.

fn sinh_cosh<P: Policy>(self) -> (Self, Self)

sinh(a + bi) = sinh(a)cos(b) + i*cosh(a)sin(b), cosh(a + bi) = cosh(a)cos(b) + i*sinh(a)sin(b).

fn tanh<P: Policy>(self) -> Self

tanh(a + bi) = (sinh(2a) + i*sin(2b)) / (cosh(2a) + cos(2b)).

Saturates to $\mathrm{sign}(a)$ for large $|a|$ under check_overflow; see tan, of which this is the transpose.

fn sinc<P: Policy>(self) -> Self

$\mathrm{sinc}(z) = \sin(z)/z$, with the removable singularity filled in.

fn sinc_pi<P: Policy>(self) -> Self

$\mathrm{sinc}_\pi(z) = \frac{\sin(\pi z)}{\pi z}$, singularity filled in.

Overridden so the zeros are exact. The default is sinc(z * pi), which rounds pi * Re z before reducing; the subsequent division by pi z cancels most of that error, so the default is accurate to about an ulp - but at a non-zero integer it returns ~1e-16 rather than zero. Going through the real sin_pi, which is exactly zero there, makes this exactly zero too.

That is the property that makes sinc_pi an interpolating kernel: Lanczos and sinc resampling reproduce their samples only if the kernel vanishes at every non-zero integer.

fn exp<P: Policy>(self) -> Self

e^(a + bi) = e^a * (cos(b) + i*sin(b)).

fn exph<P: Policy>(self) -> Self

exph(z) = e^z / 2.

fn exp2<P: Policy>(self) -> Self

$2^z = 2^a e^{ib\ln 2}$.

Policy

Above Average the real part goes through the real exp2. Rescaling it as exp(a ln 2) instead rounds a ln 2 first, and exp then amplifies that rounding by the argument - exp2(1000) is wrong in its tenth digit (~300 ulp) that way. The imaginary part can afford the multiply either way, feeding a sincos that reduces its own argument.

At or below Average the rescaled form is used, exp2 being the more expensive kernel and 300 ulp being well inside that tier’s budget.

fn exp10<P: Policy>(self) -> Self

$10^z = 10^a e^{ib\ln 10}$. See exp2, including the policy split.

fn exp_m1<P: Policy>(self) -> Self

$e^z - 1$, without the cancellation of forming $e^z$ and subtracting one.

fn exp2_m1<P: Policy>(self) -> Self

$2^z - 1$. Through the real exp2_m1 above Average, as exp2 is.

fn exp10_m1<P: Policy>(self) -> Self

$10^z - 1$. Through the real exp10_m1 above Average, as exp10 is.

fn powf<P: Policy>(self, e: Self) -> Self

z^w, the principal value.

fn cbrt<P: Policy>(self) -> Self

The principal cube root.

This does not agree with the real cube root of a negative real: the real cube root of -8 is -2, the principal complex one $1 + i\sqrt{3}$.

fn nth_root<P: Policy, const N: usize>(self) -> Self

The principal Nth root, $z^{1/N} = |z|^{1/N} e^{i\arg(z)/N}$.

The trait default is real-only: for odd N it takes abs() and restores the sign afterwards, which over C collapses z to its modulus and returns a real root.

fn ln<P: Policy>(self) -> Self

The principal natural logarithm: ln(z) = ln|z| + i*arg(z).

Branch cut on (-inf, 0], continuous from above; -pi <= Im(ln z) <= pi.

fn ln_1p<P: Policy>(self) -> Self

$\ln(1 + z)$, without the cancellation of forming 1 + z first.

fn log2<P: Policy>(self) -> Self

$\log_2 z = \log_2|z| + i\arg(z)\log_2 e$.

Through the real log2 rather than ln(z) * log2(e), which is the same work (one multiply fewer, in fact - the argument is scaled but ln|z| is not) and picks up whatever the element’s own log2 does. Measured identical to the rescaled form on f64, where thermite’s log2 is ln * LOG2_E; f32 has a dedicated kernel, so no policy gate is warranted either way.

fn log10<P: Policy>(self) -> Self

$\log_{10} z = \log_{10}|z| + i\arg(z)\log_{10} e$. See log2.

fn log_n<P: Policy, const N: usize>(self) -> Self

log_N(z) = ln(z) / ln(N) for a compile-time integer base.

fn ln1m_expnx_ext<P: Policy>(self, _lnx: Self) -> Self

$\ln(1 - e^{-z})$.

The _ext form lets a real vector reuse an already-computed ln(x). There is no such shortcut over C, so it forwards to the plain form.

fn asin<P: Policy>(self) -> Self

asin(z) = -i ln(iz + sqrt(1 - z^2)).

Branch cuts on (-inf, -1) (continuous from above) and (1, inf) (continuous from below); -pi/2 <= Re(asin z) <= pi/2.

fn acos<P: Policy>(self) -> Self

acos(z) = -i ln(z + i sqrt(1 - z^2)).

Branch cuts on (-inf, -1) and (1, inf); 0 <= Re(acos z) <= pi.

fn atan<P: Policy>(self) -> Self

atan(z) = (ln(1 + iz) - ln(1 - iz)) / (2i).

Branch cuts on (-inf*i, -i] and [i, inf*i); -pi/2 <= Re(atan z) <= pi/2.

fn asinh<P: Policy>(self) -> Self

asinh(z) = ln(z + sqrt(1 + z^2)).

fn acosh<P: Policy>(self) -> Self

acosh(z) = 2 ln(sqrt((z+1)/2) + sqrt((z-1)/2)).

Branch cut on (-inf, 1), continuous from above.

fn atanh<P: Policy>(self) -> Self

atanh(z) = (ln(1 + z) - ln(1 - z)) / 2.

Branch cuts on (-inf, -1] and [1, inf).

fn sin<P>(self) -> Self

where P: Policy,

fn cos<P>(self) -> Self

where P: Policy,

fn sin_pi<P>(self) -> Self

where P: Policy,

fn cos_pi<P>(self) -> Self

where P: Policy,

fn tan_pi<P>(self) -> Self

where P: Policy,

fn sinh<P>(self) -> Self

where P: Policy,

fn cosh<P>(self) -> Self

where P: Policy,

fn sqrt1pm1<P>(self) -> Self

where P: Policy,

fn compound<P>(self, n: Self) -> Self

where P: Policy,

fn powf_m1<P>(self, e: Self) -> Self

where P: Policy,

fn haversin<P>(self) -> Self

where P: Policy,

fn versin<P>(self) -> Self

where P: Policy,

fn cos_m1<P>(self) -> Self

where P: Policy,

fn log2_p1<P>(self) -> Self

where P: Policy,

fn log10_p1<P>(self) -> Self

where P: Policy,

fn log<P>(self, base: Self) -> Self

where P: Policy,

fn ln1m_expnx<P>(self) -> Self

where P: Policy,

ln(1 - e^(-x))

impl<V: RealFloatVector> SplatVector<Complex<<V as GenericVector>::Element>> for Complex<V>

type Splat<T: SplatConst<Complex<V::Element>>> = Complex<V>

For a given constant carrier T, the type exposing the splatted vector constant via VectorValue.

impl<V: RealValue> Square for Complex<V>

type Output = Complex<V>

The squared value. Not always Self: a type may widen to hold the product.

fn square(self) -> Self

Computes self * self.

impl<V: RealFloatVector> SquareMasked<<V as GenericVector>::Mask> for Complex<V>

fn square_c(self, mask: V::Mask) -> Self::Output

Computes Square where mask is true, does nothing where false.

fn square_m(self, src: Self, mask: V::Mask) -> Self::Output

Merges Square with src using mask, returning src where mask is false.

fn square_z(self, mask: V::Mask) -> Self::Output

Computes Square masked (zeroed where mask is false).

impl<V: PartialEq> StructuralPartialEq for Complex<V>

impl<V: RealValue> Sub for Complex<V>

type Output = Complex<V>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<V: RealValue> Sub<V> for Complex<V>

type Output = Complex<V>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<V: RealValue, T> SubAssign<T> for Complex<V>

where Self: Sub<T, Output = Self>,

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<V: RealFloatVector, Rhs> SubAssignMasked<<V as GenericVector>::Mask, Rhs> for Complex<V>

where Complex<V>: Sub<Rhs, Output = Self>,

fn sub_assign_c(&mut self, mask: V::Mask, rhs: Rhs)

Computes SubAssign with rhs where mask is true.

fn sub_assign_m(&mut self, src: Self, mask: V::Mask, rhs: Rhs)

Merges SubAssign with src using mask, assigning src where mask is false.

fn sub_assign_z(&mut self, mask: V::Mask, rhs: Rhs)

Computes SubAssign masked (zeroed where mask is false).

impl<V: RealFloatVector, Rhs> SubMasked<<V as GenericVector>::Mask, Rhs> for Complex<V>

where Complex<V>: Sub<Rhs, Output = Self>,

fn sub_c(self, mask: V::Mask, rhs: Rhs) -> Self

Computes Sub with rhs where mask is true.

fn sub_m(self, src: Self, mask: V::Mask, rhs: Rhs) -> Self

Merges Sub with src using mask, returning src where mask is false.

fn sub_z(self, mask: V::Mask, rhs: Rhs) -> Self

Computes Sub masked (zeroed where mask is false).

impl<V: RealValue> Sum for Complex<V>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<V: RealFloatVector> Swizzle<<V as GenericVector>::Lanes> for Complex<V>

fn swizzle(self, other: Self, indices: GenericArray<u32, V::Lanes>) -> Self

Swizzle lanes from two vectors according to the given indices.

fn permute(self, indices: GenericArray<u32, V::Lanes>) -> Self

Permute lanes from a single vector according to the given indices.

fn swizzle_const<I: SwizzleIndices<V::Lanes>>(self, other: Self) -> Self

fn permute_const<I: SwizzleIndices<V::Lanes>>(self) -> Self

impl<V: RealFloatVector, E: SplatConst<Complex<V::Element>>> VectorValue<E, Complex<V>> for Complex<V>

const VALUE: Complex<V>

The materialized vector constant.