Struct Compensated 

#[repr(C)]
pub struct Compensated<V> {
    pub value: V,
    pub error: V,
}

Compensated arithmetic number type.

This type represents a number as the sum of two components: a high-order value and a low-order error term. Using these, it can effectively double the mantissa precision of standard floating-point types, providing significantly improved accuracy for a wide range of numerical computations.

Compensated<f32 | f64> have some functionality required for use as an Element in vectorized types, but cannot use the math library. Use Vector<f32> or Vector<f64> as the inner type for full functionality.

Fields

value: V

error: V

Implementations

impl<V: ScalarValue> Compensated<V>

pub const fn new(value: V) -> Self

Creates a new compensated number with zero error term.

pub fn value(self) -> V

Returns the normalized value (value + error).

Strict, so a re-bracketing into surrounding arithmetic cannot discard the second word instead of rounding it in.

pub const fn uncompensated(self) -> V

Returns the uncompensated value, with no error term applied.

pub const fn error(self) -> V

Returns the error term.

pub fn normalize(self) -> Self

impl<V: CompensatedFloatVector> Compensated<V>

pub fn splat_value(value: V::Element) -> Self

impl<V: ScalarValue> Compensated<V>

pub fn accumulate_unnormalized(&mut self, rhs: Self)

Accumulate rhs into self without renormalization.

This should only be used in specific scenarios where renormalization is not desired, such as within iterative series expansions.

pub fn reduce_unnormalized(&mut self, rhs: Self)

Reduce rhs from self without renormalization.

This should only be used in specific scenarios where renormalization is not desired, such as within iterative series expansions.

impl<V: ScalarValue> Compensated<V>

pub fn div_scalar(num: V, denom: Self) -> Self

impl<V: ScalarValue> Compensated<V>

pub fn from_fraction(numerator: V, denominator: V) -> Self

Creates a compensated number from a fraction numerator / denominator, dividing with compensation.

impl Compensated<f32>

pub const fn from_f64(v: f64) -> Self

Create a compensated f32 value from an f64 value, preserving as much precision as possible.

Trait Implementations

impl<V: ScalarValue> Add for Compensated<V>

type Output = Compensated<V>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<V: ScalarValue> Add<V> for Compensated<V>

type Output = Compensated<V>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<V: Copy, T> AddAssign<T> for Compensated<V>

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

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<V: CompensatedFloatVector, Rhs> AddAssignMasked<<V as GenericVector>::Mask, Rhs> for Compensated<V>

where Compensated<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: CompensatedFloatVector, Rhs> AddMasked<<V as GenericVector>::Mask, Rhs> for Compensated<V>

where Compensated<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: CompensatedFloatVector> AddSubExt for Compensated<V>

type Output = Compensated<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: CompensatedFloatVector> AddSubExtMasked<<V as GenericVector>::Mask> for Compensated<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 BernoulliNumbers for Compensated<f32>

Available on crate feature special only.

const B2N: &'static [Compensated<f32>]

$B_2, B_4, B_6, \ldots$, every even-index Bernoulli number finite in Self, starting at $B_2$, so that entry i is $B_{2i+2}$.

impl BernoulliNumbers for Compensated<f64>

Available on crate feature special only.

const B2N: &'static [Compensated<f64>]

$B_2, B_4, B_6, \ldots$, every even-index Bernoulli number finite in Self, starting at $B_2$, so that entry i is $B_{2i+2}$.

impl<V: CompensatedFloatVector> Bounded for Compensated<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<Compensated<FROM>> for Compensated<TO>

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

fn cast_into(self) -> Compensated<FROM>

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

fn cast_from(from: Compensated<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 Compensated<V>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: ScalarValue> ConstDefault for Compensated<V>

const DEFAULT: Self

The constant default value.

impl<V: Copy> Copy for Compensated<V>

impl<V: Debug> Debug for Compensated<V>

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

Formats the value using the given formatter.

impl<V: Default> Default for Compensated<V>

fn default() -> Compensated<V>

Returns the “default value” for a type.

impl<V: PrettyPrintScalar> Display for Compensated<V>

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

Formats the value using the given formatter.

impl<V: ScalarValue> Div for Compensated<V>

type Output = Compensated<V>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<V: ScalarValue> Div<V> for Compensated<V>

type Output = Compensated<V>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<V: Copy, T> DivAssign<T> for Compensated<V>

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

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<V: CompensatedFloatVector, Rhs> DivAssignMasked<<V as GenericVector>::Mask, Rhs> for Compensated<V>

where Compensated<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: CompensatedFloatVector, Rhs> DivMasked<<V as GenericVector>::Mask, Rhs> for Compensated<V>

where Compensated<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: ScalarValue + Element> Element for Compensated<E>

const ONE: Self

const ZERO: Self

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 EllipticConsts for Compensated<f64>

Available on crate feature special only.

const CARLSON_THRESH: Self

(3 * 2^-104)^(1/8)

const RC_SERIES_THRESH: Self

2^-14: the R_C series tail t^8/17 is then 1e-34. Below this the ln arm of the closed form loses about eps/s with s ~ sqrt(t) = 0.008, a few units of 1e-30, which is the accuracy floor of R_J on this type.

impl EllipticConsts for Compensated<f32>

Available on crate feature special only.

const CARLSON_THRESH: Self

(3 * 2^-46)^(1/8)

const RC_SERIES_THRESH: Self

1/128 still: the tail 1.5e-17 is below this type’s 2^-46.

impl<V: CompensatedFloatVector> ExpIntDetails<Compensated<<V as GenericVector>::Element>, Compensated<V>> for Compensated<V>

where Compensated<V>: FloatVector<Element = Compensated<V::Element>>,

Available on crate feature special only.

Double-double is still real arithmetic, so the regime and domain rules apply unchanged - but the Lentz sentinel does not.

fn cf_tiny() -> Compensated<V>

The default, MIN_POSITIVE, is reciprocated on the first Lentz step, and 1/2.2e-308 = 4.5e307 is past the ~1.3e300 where compensated multiplication’s Dekker 2^27+1 splitter overflows to infinity - so every continued-fraction lane came back NaN. expint takes the fraction for x >= 1, which is exactly where it failed.

Same defect and same fix as Complex, and as the erf/erfc tail in this crate: a sentinel only has to be negligible as a floor, but this one also has to survive being inverted.

fn use_series(z: V) -> <V as GenericVector>::Mask

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

fn invalid(z: V) -> <V as GenericVector>::Mask

Lanes outside the domain, forced to NaN when the policy checks overflow.

impl<V: ScalarValue> FloatConsts for Compensated<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_1_SQRT_5: Self

$1/\sqrt{5}$

const FRAC_2_PI: Self

$2/\pi$

const FRAC_1_SQRT_PI: Self

$1/\sqrt{\pi}$

const FRAC_1_SQRT_SQRT_PI: Self

$\pi^{-1/4}$, the normalization of the Hermite functions

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 LN_TAU: Self

$\ln 2\pi$

const LN_9: Self

$\ln 9$

const NINE_LN_9_HI: Self

$9 \ln 9$, the high word of the two-word split used by the Stirling shift in thermite-special’s Poisson kernel. $9 \ln 9 \approx 19.8$ sits in an exponent, where one rounding of it is about 8 ulp of the density.

const NINE_LN_9_LO: Self

$9 \ln 9$ minus NINE_LN_9_HI, exactly. Format-dependent like the epsilons.

const FRAC_LN_PI_2: Self

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

const FRAC_LN_TAU_2: Self

$\frac{1}{2}\ln 2\pi$, the constant term of the Stirling series for $\ln \Gamma$

const LOG2_10: Self

$\log_2 10$

const LOG2_E: Self

$\log_2 e$

const LOG2_PI: Self

$\log_2 \pi$

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_5: Self

$\sqrt{5}$

const SQRT_E: Self

$\sqrt{e}$

const EPSILON: Self

The machine epsilon

const SQRT_EPSILON: Self

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

const FOURTH_ROOT_EPSILON: Self

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

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_PHI: Self

$1/\varphi = \varphi - 1$, the 1D golden-ratio low-discrepancy increment

const FRAC_1_PHI_SQUARED: Self

$1/\varphi^2$

const GOLDEN_ANGLE: Self

The golden angle $2\pi/\varphi^2 = \pi(3 - \sqrt{5})$ in radians

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_1_E: Self

$1/e$

const FRAC_NEG_1_E: Self

$-1/e$

const FRAC_1_2: Self

$1/2$

const FRAC_3_4: Self

$3/4$

const LN_LN_2: Self

$\ln(\ln 2)$, the median of the Gumbel distribution

const SQRT_LN_4: Self

$\sqrt{\ln 4}$

const FRAC_2PI_3: Self

$2\pi/3$

const FRAC_3PI_4: Self

$3\pi/4$

const FRAC_4PI_3: Self

$4\pi/3$, the volume of the unit sphere

const FOUR_PI: Self

$4\pi$, the solid angle of the whole sphere in steradians

const FRAC_1_4PI: Self

$1/(4\pi)$, the density of the uniform distribution on the sphere

const FRAC_1_TAU: Self

$1/(2\pi)$

const SQRT_PI: Self

$\sqrt{\pi}$

const PI_MINUS_3: Self

$\pi - 3$

const FOUR_MINUS_PI: Self

$4 - \pi$

const PI_POW_E: Self

$\pi^e$

const CBRT_2: Self

$\sqrt[3]{2}$

const CBRT_3: Self

$\sqrt[3]{3}$

const CBRT_PI: Self

$\sqrt[3]{\pi}$

const FRAC_1_CBRT_PI: Self

$1/\sqrt[3]{\pi}$

const FRAC_1_SQRT_E: Self

$1/\sqrt{e} = e^{-1/2}$

const E_POW_PI: Self

$e^\pi$, Gelfond’s constant

const GELFOND_SCHNEIDER: Self

$2^{\sqrt{2}}$, the Gelfond-Schneider constant (also called Hilbert’s number)

const SIN_1: Self

$\sin 1$

const COS_1: Self

$\cos 1$

const TAN_1: Self

$\tan 1$

const SINH_1: Self

$\sinh 1$

const COSH_1: Self

$\cosh 1$

const TANH_1: Self

$\tanh 1$

const LN_PHI: Self

$\ln \varphi$

const FRAC_1_LN_PHI: Self

$1/\ln \varphi$

const FRAC_1_EULER_GAMMA: Self

$1/\gamma$

const EULER_GAMMA_SQUARED: Self

$\gamma^2$

const ZETA_2: Self

$\zeta(2) = \pi^2/6$

const ZETA_3: Self

$\zeta(3)$, Apery’s constant

const ZETA_4: Self

$\zeta(4) = \pi^4/90$

const CATALAN: Self

Catalan’s constant $K$

const GLAISHER: Self

The Glaisher-Kinkelin constant $A$

const KHINCHIN: Self

Khinchin’s constant $K_0$

const LEVY: Self

Levy’s constant $e^{\pi^2/(12\ln 2)}$

const EXTREME_VALUE_SKEWNESS: Self

$12\sqrt{6}\,\zeta(3)/\pi^3$, the skewness of the extreme value distribution

const RAYLEIGH_SKEWNESS: Self

$2\sqrt{\pi}(\pi-3)/(4-\pi)^{3/2}$, the skewness of the Rayleigh distribution

const RAYLEIGH_KURTOSIS_EXCESS: Self

$-(6\pi^2 - 24\pi + 16)/(4-\pi)^2$, the excess kurtosis of the Rayleigh distribution

const RAYLEIGH_KURTOSIS: Self

$3 - (6\pi^2 - 24\pi + 16)/(4-\pi)^2$, the kurtosis of the Rayleigh distribution

const FEIGENBAUM_DELTA: Self

The first Feigenbaum constant $\delta$

const PLASTIC_RATIO: Self

The plastic ratio $\rho$, the real root of $x^3 = x + 1$

const FRAC_1_PLASTIC_RATIO: Self

$1/\rho$, the first increment of the 2D R2 low-discrepancy sequence

const FRAC_1_PLASTIC_RATIO_SQUARED: Self

$1/\rho^2$, the second R2 increment

const GAUSS: Self

Gauss’s constant $G = 1/\mathrm{agm}(1, \sqrt{2})$

const LEMNISCATE: Self

The lemniscate constant $\varpi = \pi G = 2\int_0^1 dt/\sqrt{1-t^4}$

const DOTTIE: Self

The Dottie number, the unique real solution of $\cos x = x$

const OMEGA: Self

The omega constant $\Omega$, the solution of $\Omega e^{\Omega} = 1$, i.e. $W(1)$

const PSI: Self

The reciprocal Fibonacci constant $\psi = \sum_{k=1}^{\infty} 1/F_k$

const LAPLACE_LIMIT: Self

The Laplace limit, the root of $x e^{\sqrt{1+x^2}} / (1 + \sqrt{1+x^2}) = 1$

const ERDOS_BORWEIN: Self

The Erdos-Borwein constant $E = \sum_{k=1}^{\infty} 1/(2^k - 1)$

const NIVEN: Self

Niven’s constant $1 + \sum_{k=2}^{\infty} (1 - 1/\zeta(k))$, the average maximum prime exponent

const SOLDNER: Self

The Ramanujan-Soldner constant $\mu$, the positive root of the logarithmic integral $\mathrm{li}(x)$

const FRANSEN_ROBINSON: Self

The Fransen-Robinson constant $\int_0^{\infty} dx/\Gamma(x)$

const GOLOMB_DICKMAN: Self

The Golomb-Dickman constant $\lambda = \int_0^1 e^{\mathrm{li}(t)}\,dt$

const TWIN_PRIME: Self

The twin prime constant $C_2 = \prod_{p \ge 3} (1 - 1/(p-1)^2)$

const MERTENS: Self

The Meissel-Mertens constant $M = \gamma + \sum_p (\ln(1 - 1/p) + 1/p)$

const ARTIN: Self

Artin’s constant $A = \prod_p (1 - 1/(p(p-1)))$

impl<E: ScalarValue + FloatElement> FloatElement for Compensated<E>

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 N: LargeInt> = <E as ScalarValue>::CompensatedConstInt<N>

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

type ConstRatio<const N: LargeInt, const D: LargeInt> = <E as ScalarValue>::CompensatedConstRatio<N, D>

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

fn sqrt(this: Self) -> Self

fn floor(this: Self) -> Self

fn ceil(this: Self) -> Self

fn round(this: Self) -> Self

Round to nearest, ties to even.

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: CompensatedFloatVector> FloatVector for Compensated<V>

type ExtendedPrecision = Compensated<V>

Don’t use Compensated if you need to go higher precision than it provides.

If you absolutely must, use CastVector to convert to a higher-precision type.

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 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 EPSILON: Self

Hardware epsilon value in this vector type.

const HAS_APPROX_RCP: bool = false

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 = false

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().

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_nan(self) -> Self::Mask

Check if each element in the vector is NaN, 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 sqrt(self) -> Self

Lane-wise IEEE 754 square root.

fn rsqrt(self) -> Self

Lane-wise approximate reciprocal square root.

fn rcp(self) -> Self

Lane-wise approximate reciprocal: 1 / self.

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, ties to even (banker’s rounding).

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 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, ties to even (banker’s rounding).

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

Lane-wise round-to-nearest, ties to even (banker’s rounding).

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

Lane-wise round-to-nearest, ties to even (banker’s rounding).

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 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 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: CompensatedFloatVector> GenericSelectable for Compensated<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: CompensatedFloatVector> GenericVector for Compensated<V>

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

A Compensated element is #[repr(C)] over two floats (value, error), so M interleaved Compensated streams are exactly 2 * M interleaved float streams, precisely a grouped problem with TAIL = 1 (see StreamGroup). This hands M straight to the inner vector’s GenericVector::load_deinterleaved_grouped (a NEON LD2/LD3/LD4, or a shuffle network on x86), for any M: no dispatch ladder, no scalar fallback.

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

The exact inverse of load_deinterleaved.

const EMPTY: Self

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 = Compensated<<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 permutev(self, indices: Self::Unsigned) -> Self

Permute lanes by a live index vector: lane i of the result is self[indices[i]].

fn swizzle(self, other: Self, indices: Self::Unsigned) -> Self

Select lanes from the concatenation [self, other] by a live index vector: index i < LANES takes self[i], LANES <= i < 2*LANES takes other[i - LANES].

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.

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 load_unaligned(ptr: *const Self::Element) -> Self

Load a vector from an unaligned 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.

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

Store the vector to an aligned pointer to its elements.

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 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 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_element(self) -> Self::Element

Extract lane 0 – the scalar counterpart to single.

fn last_element(self) -> Self::Element

Extract the last lane (LANES - 1), first_element’s counterpart at the other end.

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 compress_n<const N: usize>(values: [Self; N], mask: Self::Mask) -> [Self; N]

Apply one mask’s compress to N vectors.

fn compress_z_n<const N: usize>( values: [Self; N], mask: Self::Mask, ) -> [Self; N]

Apply one mask’s compress_z to N vectors. See compress_n.

fn expand_n<const N: usize>(values: [Self; N], mask: Self::Mask) -> [Self; N]

Apply one mask’s expand to N vectors. See compress_n.

fn expand_z_n<const N: usize>(values: [Self; N], mask: Self::Mask) -> [Self; N]

Apply one mask’s expand_z to N vectors. See compress_n.

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 Compensated<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: CompensatedFloatVector> Interleave for Compensated<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: ScalarValue> Mul for Compensated<V>

type Output = Compensated<V>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<V: ScalarValue> Mul<V> for Compensated<V>

type Output = Compensated<V>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<V: Copy, A, B> MulAddAssignExt<A, B> for Compensated<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: CompensatedFloatVector, A, B> MulAddAssignExtMasked<<V as GenericVector>::Mask, A, B> for Compensated<V>

where Compensated<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: ScalarValue> MulAddExt for Compensated<V>

const HAS_NATIVE_FMA: Tribool = tribool::True

Whether the implementation uses native fused-multiply-add instructions, as three-valued logic: True = fused single instructions, False = definitely separate multiply and add, Indeterminate = decided at runtime (e.g. the wasm relaxed-madd canary).

type Output = Compensated<V>

The result of the fused operation.

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

Guaranteed fused-multiply-add operation.

fn mul_sub(self, b: Self, c: Self) -> Self::Output

Guaranteed fused-multiply-subtract operation.

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

Guaranteed fused-negated-multiply-add operation.

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

Guaranteed fused-negated-multiply-subtract operation.

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

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::Output

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::Output

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::Output

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: ScalarValue> MulAddExt<Compensated<V>, V> for Compensated<V>

const HAS_NATIVE_FMA: Tribool = tribool::True

Whether the implementation uses native fused-multiply-add instructions, as three-valued logic: True = fused single instructions, False = definitely separate multiply and add, Indeterminate = decided at runtime (e.g. the wasm relaxed-madd canary).

type Output = Compensated<V>

The result of the fused operation.

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

Guaranteed fused-multiply-add operation.

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

Guaranteed fused-multiply-subtract operation.

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

Guaranteed fused-negated-multiply-add operation.

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

Guaranteed fused-negated-multiply-subtract operation.

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

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: V) -> Self::Output

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: V) -> Self::Output

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: V) -> Self::Output

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: ScalarValue> MulAddExt<V> for Compensated<V>

const HAS_NATIVE_FMA: Tribool = tribool::True

Whether the implementation uses native fused-multiply-add instructions, as three-valued logic: True = fused single instructions, False = definitely separate multiply and add, Indeterminate = decided at runtime (e.g. the wasm relaxed-madd canary).

type Output = Compensated<V>

The result of the fused operation.

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

Guaranteed fused-multiply-add operation.

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

Guaranteed fused-multiply-subtract operation.

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

Guaranteed fused-negated-multiply-add operation.

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

Guaranteed fused-negated-multiply-subtract operation.

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

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::Output

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::Output

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::Output

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: CompensatedFloatVector, A, B> MulAddExtMasked<<V as GenericVector>::Mask, A, B> for Compensated<V>

where Compensated<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: Copy, T> MulAssign<T> for Compensated<V>

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

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<V: CompensatedFloatVector, Rhs> MulAssignMasked<<V as GenericVector>::Mask, Rhs> for Compensated<V>

where Compensated<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: CompensatedFloatVector, Rhs> MulMasked<<V as GenericVector>::Mask, Rhs> for Compensated<V>

where Compensated<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: ScalarValue> Neg for Compensated<V>

type Output = Compensated<V>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<V: CompensatedFloatVector> NegMasked<<V as GenericVector>::Mask> for Compensated<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: CompensatedFloatVector> NewVector<Compensated<<V as GenericVector>::Element>, <V as GenericVector>::Lanes> for Compensated<V>

type New<T: NewConst<Compensated<V::Element>, V::Lanes>> = CompensatedNewImpl

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

impl<V: CompensatedFloatVector> NumericVector for Compensated<V>

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

Lane sorts are keyed on the lexicographic (value, error) order, which is exactly cmp_lt here, so the key IS the comparison and ties are deterministic. Each compare-exchange derives one routing mask from it and moves both components through the same permutation and select (thermite::sort::sort_lanes_by_key).

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 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 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 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 sum_elements(self) -> Self::Element

Returns the sum of all elements in the vector.

fn prod_elements(self) -> Self::Element

Returns the product 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 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 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 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 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 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 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 Compensated<V>

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

Equality operator ==.

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

Inequality operator !=.

impl<V: PartialOrd> PartialOrd for Compensated<V>

fn partial_cmp(&self, other: &Compensated<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: CompensatedFloatVector> PartialOrdVector for Compensated<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: ScalarValue> Product for Compensated<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: ScalarValue> Rem for Compensated<V>

type Output = Compensated<V>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<V: ScalarValue> Rem<V> for Compensated<V>

type Output = Compensated<V>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<V: Copy, T> RemAssign<T> for Compensated<V>

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

fn rem_assign(&mut self, rhs: T)

Performs the %= operation.

impl<V: CompensatedFloatVector, Rhs> RemAssignMasked<<V as GenericVector>::Mask, Rhs> for Compensated<V>

where Compensated<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: CompensatedFloatVector, Rhs> RemMasked<<V as GenericVector>::Mask, Rhs> for Compensated<V>

where Compensated<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: ScalarValue + SignedElement> SignedElement for Compensated<E>

fn abs(self) -> Self

fn signum(self) -> Self

impl<V: CompensatedFloatVector> SignedVector for Compensated<V>

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 abs(self) -> Self

Take the absolute value of the vector, element-wise.

fn signum(self) -> Self

For each element in the vector, return a new vector where each element is either -1 or +1 depending on the sign of the element.

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, 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. Computes copysign when mask is true, returns self where false.

fn copysign_m(self, src: Self, mask: Self::Mask, 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. Merges copysign with src using mask.

fn copysign_z(self, mask: Self::Mask, 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. Computes copysign masked (zeroed where mask is false).

impl<V: CompensatedFloatVector> SortKey<Compensated<V>> for Compensated<V>

The lane-sort key: strictly-before under the lexicographic (value, error) 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> SpecializedCoreMath<Compensated<<V as GenericVector>::Element>> for Compensated<V>

where V: RealMathWithPolicy + CompensatedFloatVector,

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

fn poly_n_primal<P, N>(self, coeffs: &GenericArray<Self::Primal, N>) -> Self

where P: Policy, N: ArrayLength,

Backing definition of CoreMath::poly_n_primal.

fn poly_rev_n_primal<P, N>(self, coeffs: &GenericArray<Self::Primal, N>) -> Self

where P: Policy, N: ArrayLength,

Backing definition of CoreMath::poly_rev_n_primal.

fn poly_primal<P>(self, coeffs: &[Self::Primal]) -> Self

where P: Policy,

Backing definition of CoreMath::poly_primal.

fn poly_rev_primal<P>(self, coeffs: &[Self::Primal]) -> Self

where P: Policy,

Backing definition of CoreMath::poly_rev_primal.

fn mul_add_primal<P>(self, m: Self, a: Self::Primal) -> Self

where P: Policy,

One Horner step against a primal addend: self * m + a.

fn nmul_add_primal<P>(self, m: Self, a: Self::Primal) -> Self

where P: Policy,

-(self * m) + a, the negated twin of mul_add_primal.

fn difference_of_products<P>(self, b: Self, c: Self, d: Self) -> Self

where P: Policy,

The naive form, the fallback for composite arithmetics only.

fn sum_of_products<P>(self, b: Self, c: Self, d: Self) -> Self

where P: Policy,

The naive form, the fallback for composite arithmetics only. See difference_of_products.

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

where P: Policy,

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

where P: Policy,

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

where P: Policy,

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

where P: Policy,

fn poly_rational_n<P, const N: usize, const D: usize>( self, numerator: &[E; N], denominator: &[E; D], ) -> Self

where P: Policy,

fn approx_reciprocal<P>(self) -> Self

where P: Policy,

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

where P: Policy,

fn approx_div_sqrt<P>(self, denom: Self) -> Self

where P: Policy,

$a/\sqrt{b}$, spelled a.approx_div_sqrt(b), as one kernel rather than a divide bolted onto a square root.

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

where P: Policy,

numer / sum(1/x_i) the direct way, backing both harmonic_mean and inv_sum_inv, which differ only in whether the numerator is N or 1.

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

where P: Policy,

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

where P: Policy,

fn inv_sum_inv<P>(values: &[Self]) -> Self

where P: Policy,

$1/\sum_i 1/x_i$ over a runtime-length slice.

fn harmonic_mean<P>(values: &[Self]) -> Self

where P: Policy,

$N/\sum_i 1/x_i$ over a runtime-length slice.

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> SpecializedPrimalMath<Compensated<<V as GenericVector>::Element>> for Compensated<V>

where V: RealMathWithPolicy + CompensatedFloatVector,

impl<V> SpecializedRealMath<Compensated<<V as GenericVector>::Element>> for Compensated<V>

where V: RealMathWithPolicy + CompensatedFloatVector,

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

fn tolerance<P>() -> Self

where P: Policy,

fn to_degrees<P>(self) -> Self

where P: Policy,

fn entr<P>(self) -> Self

where P: Policy,

-x ln x, 0 at zero, -inf below it. The zero case rides the shared guard, since ln 0 is the same 0 * -inf that xlogy exists to absorb. Only the negative branch is specific to this one.

fn ln_ratio<P>(x: Self, y: Self) -> Self

where P: Policy,

ln(x/y) for positive x and y, accurate near x = y where the plain ratio is not. The shared core of rel_entr and kl_div.

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

where P: Policy,

x ln(x/y), the Kullback-Leibler summand, extended by 0 at x = 0, y >= 0 and +inf everywhere else in the plane.

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

where P: Policy,

rel_entr plus the Bregman tail -x + y, which is what makes this non-negative for unnormalized arguments. Note the x = 0 case is y, not 0: the tail survives when the log term vanishes.

fn to_radians<P>(self) -> Self

where P: Policy,

fn wrap_angle<P>(self) -> Self

where P: Policy,

fn angle_diff<P>(self, other: Self) -> Self

where P: Policy,

fn step<P>(self, t: Self) -> Self

where P: Policy,

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

where P: Policy,

fn rescale<P>( self, in_min: Self, in_max: Self, out_min: Self, out_max: Self, ) -> Self

where P: Policy,

fn logaddexp<P>(self, other: Self) -> Self

where P: Policy,

fn logmean<P>(self, other: Self) -> Self

where P: Policy,

fn logsumexp<P>(values: &[Self]) -> Self

where P: Policy,

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

where P: Policy,

fn logsubexp<P>(self, other: Self) -> Self

where P: Policy,

fn smoothstep<P, const N: usize>(self, edges: Option<(Self, Self)>) -> Self

where P: Policy,

fn smoothstep_derivative<P, const N: usize>( self, edges: Option<(Self, Self)>, ) -> Self

where P: Policy,

fn inverse_smoothstep<P, const N: usize>( y: Self, edges: Option<(Self, Self)>, ) -> Self

where P: Policy,

fn smooth_interpolator<P>(x: Self, edges: Option<(Self, Self)>, k: Self) -> Self

where P: Policy,

fn smooth_interpolator_inverse<P>( y: Self, edges: Option<(Self, Self)>, k: Self, ) -> Self

where P: Policy,

impl<V> SpecializedRealPrimalMath<Compensated<<V as GenericVector>::Element>> for Compensated<V>

where V: SpecialMathWithPolicy + RealSpecialMathWithPolicy + RealMathWithPolicy + SpecializedCompensatedSpecialMath<V::Element> + CompensatedFloatVector,

Available on crate feature special only.

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

L(x) and L'(x). The derivative falls out of the value’s own intermediates on both branches (see generic::langevin), so there is no default here that would recompute it.

fn spherical_harmonics_d_with<P, const L: usize, const N: usize>( table: &ShTable<Self, N>, x: Self, y: Self, z: Self, out: &mut [Self; N], ddx: &mut [Self; N], ddy: &mut [Self; N], ddz: &mut [Self; N], )

where P: Policy,

spherical_harmonics_with plus the ambient Cartesian gradients, from a prebuilt table.

fn spherical_harmonics_d<P, const L: usize, const N: usize, const CS: bool>( x: Self, y: Self, z: Self, out: &mut [Self; N], ddx: &mut [Self; N], ddy: &mut [Self; N], ddz: &mut [Self; N], )

where P: Policy,

spherical_harmonics plus the ambient Cartesian gradient of every harmonic. See sh_d_impl for the gradient semantics.

fn zernike_basis_d<P, const L: usize, const NORM: u8, const N: usize>( x: Self, y: Self, out: &mut [Self; N], ddx: &mut [Self; N], ddy: &mut [Self; N], )

where P: Policy,

zernike_basis plus the Cartesian gradient of every mode. See zernike_basis_d_impl for the algorithm.

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

where P: Policy,

fn gelu_d<P>(self, alpha: Self) -> (Self, Self)

where P: Policy,

fn swish_d<P>(self, beta: Self) -> (Self, Self)

where P: Policy,

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

where P: Policy,

fn algebraic_sigmoid_d<P>(self, n: u32) -> (Self, Self)

where P: Policy,

The runtime twin of algebraic_sigmoid_d_n.

fn algebraic_swish_d<P>(self) -> (Self, Self)

where P: Policy,

impl<V> SpecializedRealSpecialMath<Compensated<<V as GenericVector>::Element>> for Compensated<V>

where V: SpecialMathWithPolicy + RealSpecialMathWithPolicy + RealMathWithPolicy + SpecializedCompensatedSpecialMath<V::Element> + CompensatedFloatVector,

Available on crate feature special only.

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

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

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

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

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

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

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

fn ndtr<P>(self) -> Self

where P: Policy,

erfc(-x/sqrt 2)/2, the standard normal CDF.

fn log_ndtr<P>(self) -> Self

where P: Policy,

ln(ndtr(x)), finite wherever x is: ln(erfc) in the moderate region, erfcx with -x^2/2 kept in the log domain in the tail, ln_1p of the complement on the right. See generic::ndtr. Element types without a Weideman table (Compensated) inherit their direct erfcx’s range, about |x| < 37.

fn logerfc<P>(self) -> Self

where P: Policy,

ln(erfc(x)) on the same construction as log_ndtr, with the tail on the right and ln_1p(+-erf(|x|)) on the bounded side.

fn log_ndtr_with_deriv<P>(self) -> (Self, Self)

where P: Policy,

(ln ndtr(x), phi(x)/ndtr(x)), the value with the inverse Mills ratio, which is its derivative. What inv_log_ndtr’s Newton and Dual both need.

fn inv_log_ndtr<P>(self) -> Self

where P: Policy,

The x with ln ndtr(x) = y. Newton on log_ndtr.

fn inv_digamma<P>(self) -> Self

where P: Policy,

The x > 0 with digamma(x) = y. Newton on digamma with trigamma, and the Stirling fixed point above y = 6.

fn wright_omega<P>(self) -> Self

where P: Policy,

The w > 0 with w + ln w = x. Newton, and the Lagrange series below x = -7.

fn fresnel<P>(self) -> (Self, Self)

where P: Policy,

(S(x), C(x)), the Fresnel integrals. See generic::fresnel.

fn sici<P>(self) -> (Self, Self)

where P: Policy,

(Si(x), Ci(x)), the trigonometric integrals. See generic::sici.

fn fresnel_c<P>(self) -> Self

where P: Policy,

C(x) alone. Unlike the Airy singles this is genuinely the pair with one half dead: the two share the argument reduction, the phase and both auxiliaries, so only one Chebyshev series and one reconstruction fall out. They are pure, so they do fall out.

fn fresnel_s<P>(self) -> Self

where P: Policy,

S(x) alone. See fresnel_c.

fn sinint<P>(self) -> Self

where P: Policy,

Si(x) alone. See fresnel_c for what is and is not saved.

fn cosint<P>(self) -> Self

where P: Policy,

Ci(x) alone. See fresnel_c.

fn bessel_i_ratio<P>(self, _nu: Self) -> Self

where P: Policy,

I_nu(x) / I_{nu-1}(x), the vMF mean resultant length. See generic::bessel_ratio.

fn inv_bessel_i_ratio<P>(self, _nu: Self) -> Self

where P: Policy,

The kappa with I_nu(kappa) / I_{nu-1}(kappa) = r. Newton on the ratio. Same arrangement as bessel_i_ratio.

fn bessel_i_ratio_1m<P>(self, _nu: Self) -> Self

where P: Policy,

1 - I_nu(x) / I_{nu-1}(x), accurate where the ratio is within an ulp of 1.

fn inv_bessel_i_ratio_1m<P>(self, _nu: Self) -> Self

where P: Policy,

The kappa with 1 - I_nu(kappa) / I_{nu-1}(kappa) = t, the complement form.

fn bessel_ratio<P, F>(self, nu: Self) -> Self

where P: Policy, F: BesselRatioFamily,

bessel::ratio::<F>(nu): see BesselRatioFamily.

fn inv_bessel_ratio<P, F>(self, nu: Self) -> Self

where P: Policy, F: BesselRatioFamily,

inv_bessel::ratio::<F>(r).

fn bessel_ratio_1m<P, F>(self, nu: Self) -> Self

where P: Policy, F: BesselRatioFamily,

bessel_ratio_1m::<F>(nu).

fn inv_bessel_ratio_1m<P, F>(self, nu: Self) -> Self

where P: Policy, F: BesselRatioFamily,

inv_bessel_ratio_1m::<F>(t).

fn gauss_legendre<P>(self, n: u32) -> (Self, Self)

where P: Policy,

(x_k, w_k) of the n-point Gauss-Legendre rule, the index k per lane. See generic::quadrature.

fn gauss_hermite<P>(self, n: u32) -> (Self, Self)

where P: Policy,

(x_k, w_k) of the n-point Gauss-Hermite rule, the index k per lane.

fn gauss_laguerre<P>(self, alpha: Self, n: u32) -> (Self, Self)

where P: Policy,

(x_k, w_k) of the n-point Gauss-Laguerre rule with weight x^alpha e^{-x}, the index k and alpha per lane.

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

where P: Policy,

AGM(a, b), sharing its recurrence with the complete elliptic integrals.

fn pochhammer<P>(z: Self, m: Self) -> Self

where P: Policy,

zeta(s) - 1, the primitive of the pair: the Euler-Maclaurin sum’s leading term is the 1, so omitting it is exact where subtracting it afterwards is not.

fn jacobi_elliptic<P>(u: Self, k: Self) -> (Self, Self, Self)

where P: Policy,

(sn, cn, dn) by the arithmetic-only descending Landen transformation.

fn boxcox<P>(self, lambda: Self) -> Self

where P: Policy,

(x^lambda - 1)/lambda, ln x at lambda = 0.

fn boxcox_1p<P>(self, lambda: Self) -> Self

where P: Policy,

((1 + x)^lambda - 1)/lambda, ln(1 + x) at lambda = 0.

fn inv_boxcox<P>(self, lambda: Self) -> Self

where P: Policy,

(lambda*y + 1)^(1/lambda), e^y at lambda = 0. The inverse of boxcox.

fn inv_boxcox_1p<P>(self, lambda: Self) -> Self

where P: Policy,

(lambda*y + 1)^(1/lambda) - 1, e^y - 1 at lambda = 0. The inverse of boxcox_1p.

fn yeo_johnson<P>(self, lambda: Self) -> Self

where P: Policy,

The Yeo-Johnson transform of y = self with parameter lambda.

fn inv_yeo_johnson<P>(self, lambda: Self) -> Self

where P: Policy,

The inverse Yeo-Johnson transform. The same sign fold as yeo_johnson, over inv_boxcox_1p.

fn gelu<P>(self, alpha: Self) -> Self

where P: Policy,

fn swish<P>(self, beta: Self) -> Self

where P: Policy,

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

where P: Policy,

fn algebraic_sigmoid<P>(self, n: u32) -> Self

where P: Policy,

The runtime twin of algebraic_sigmoid_n, same arithmetic.

fn algebraic_swish<P>(self) -> Self

where P: Policy,

fn gaussian_integral<P>(x0: Self, x1: Self, a: Self, c: Self) -> Self

where P: Policy,

fn spherical_harmonics_table<P, const L: usize, const N: usize, const CS: bool>( table: &mut ShTable<Self::Primal, N>, )

where P: Policy,

Fills a runtime coefficient table for degree L and phase CS. See sh_impl for the conventions, layout, and algorithm.

fn spherical_harmonics_with<P, const L: usize, const N: usize>( table: &ShTable<Self::Primal, N>, x: Self, y: Self, z: Self, out: &mut [Self; N], )

where P: Policy,

Evaluates all harmonics through degree L from a table built by spherical_harmonics_table.

fn spherical_harmonics<P, const L: usize, const N: usize, const CS: bool>( x: Self, y: Self, z: Self, out: &mut [Self; N], )

where P: Policy,

The one-shot form: build a table and evaluate it.

impl<V> SpecializedSpatialMath<Compensated<<V as GenericVector>::Element>> for Compensated<V>

where V: RealMathWithPolicy + CompensatedFloatVector,

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

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

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

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

where P: Policy,

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

where P: Policy,

The two-argument spelling, and nothing more than a spelling.

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

where P: Policy,

fn hypot_s<P>(values: &[Self]) -> Self

where P: Policy,

fn inv_hypot<P>(values: &[Self]) -> Self

where P: Policy,

impl<V> SpecializedSpecialMath<Compensated<<V as GenericVector>::Element>> for Compensated<V>

where V: SpecialMathWithPolicy + RealSpecialMathWithPolicy + RealMathWithPolicy + SpecializedCompensatedSpecialMath<V::Element> + CompensatedFloatVector,

Available on crate feature special only.

fn polygamma<P: Policy>(self, n: u32) -> Self

n = 0 and n = 1 reach the tuned double-double digamma/trigamma. n >= 2 returns NaN: no double-double algorithm exists for the higher orders yet, and silently routing through an f64-precision path would put 53 good bits in a 106-bit container, the same reason Compensated refuses the shared Lanczos tables. NaN over quiet precision loss, like the real kernel’s unimplemented regions.

type ExpIntDetails = Compensated<V>

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

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

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

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

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

fn lambert_w<P: Policy>(self) -> (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 exp_two_sum(a: Self, b: Self) -> (Self, Self)

TwoSum for exponent assembly: (a + b, the rounding it discarded). Internal to this trait; it is a lowering detail of the Poisson exponent.

const LAGUERRE_PRODUCT_SEED_CAP: i32 = 0

Largest integer weight for which laguerre_function_i seeds by the direct product x^{alpha/2} / sqrt(alpha!) (a scalar factorial, powi, at most one sqrt) instead of the general exp(alpha/2 ln x - lgamma(alpha+1)/2). 0 disables it.

fn erfcx<P>(self) -> Self

where P: Policy,

$e^{x^2}\operatorname{erfc}(x)$, which does not underflow where erfc does.

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

where P: Policy,

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

fn expint_primal_n<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 expint<P>(self, n: u32) -> Self

where P: Policy,

The runtime-order twin of expint_n.

fn expint_primal<P>(self, n: u32) -> (Self, Self)

where P: Policy,

The runtime-order twin of expint_primal_n: the same E_1 core, the same recurrence with the order as a value.

fn logistic_sigmoid<P>(self) -> Self

where P: Policy,

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

where P: Policy,

fn zetac<P>(self) -> Self

where P: Policy,

Compensated keeps the default: the Euler-Maclaurin coefficients are tabulated to f64, so a double-double built from them would carry 53 real bits and noise, the same reason it has no GammaPrimalTables impl. Dual overrides it through zeta_with_deriv.

fn zeta<P>(self) -> Self

where P: Policy,

zeta(s), as 1 + zetac(s). Defaulted for the same reason as zetac.

fn polylog<P>( self, order: PolylogOrder<E, <Self::Signed as GenericVector>::Element>, ) -> Self

where P: Policy,

Li_s(z) at a scalar order. Defaulted for the same reason as zetac: the coefficient precompute is f64, so a double-double has nothing to reach for. Dual overrides it through the order-lowering identity Li_s' = Li_{s-1}/z.

fn zeta_with_deriv<P, const ZETAC: bool>(self) -> (Self, Self)

where P: Policy,

(zeta(s), zeta'(s)), or (zeta(s) - 1, zeta'(s)) when ZETAC is set: the two functions differ by a constant, so one derivative serves both.

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

where P: Policy,

I_N(x), or e^{-|x|} I_N(x) when SCALED: the modified Bessel function of the first kind at compile-time integer order.

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

where P: Policy,

e^{-|x|} I_N(x). Not a wrapper over bessel_i: above the series threshold the coefficient tables are the scaled value, so this form skips the exponential the unscaled one pays for, and stays finite where I_N overflows.

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

where P: Policy,

K_N(x), the modified Bessel function of the second kind at compile-time integer order. Defaulted for the same reason as bessel_i.

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

where P: Policy,

e^{x} K_N(x). Not a wrapper: above the series threshold the tables are natively the scaled quantity, so this form skips the exponential the unscaled one pays for, and stays in range where K_N has decayed to zero.

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

where P: Policy,

J_N(x), the oscillatory Bessel function of the first kind. Orders 0 and 1 only for now. Higher orders want a recurrence that is not written yet.

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

where P: Policy,

Y_N(x), the oscillatory Bessel function of the second kind.

fn bessel_i_with_deriv<P, const N: i32, const SCALED: bool>( self, ) -> (Self, Self)

where P: Policy,

(I_N(x), d/dx I_N(x)), or the scaled pair when SCALED.

fn bessel_k_with_deriv<P, const N: i32, const SCALED: bool>( self, ) -> (Self, Self)

where P: Policy,

(K_N(x), d/dx K_N(x)). See bessel_i_with_deriv.

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

where P: Policy,

(J_N(x), d/dx J_N(x)). See bessel_i_with_deriv.

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

where P: Policy,

(Y_N(x), d/dx Y_N(x)). See bessel_i_with_deriv.

fn bessel_iv<P, const SCALED: bool>( self, _order: BesselOrder<Self, Self::Signed>, ) -> Self

where P: Policy,

I_n(x) with a per-lane order. See bessel_i.

fn bessel_kv<P, const SCALED: bool>( self, _order: BesselOrder<Self, Self::Signed>, ) -> Self

where P: Policy,

K_n(x) with a per-lane order. See bessel_k.

fn bessel_jv<P>(self, _order: BesselOrder<Self, Self::Signed>) -> Self

where P: Policy,

J_n(x) with a per-lane order. See bessel_j.

fn bessel_yv<P>(self, _order: BesselOrder<Self, Self::Signed>) -> Self

where P: Policy,

Y_n(x) with a per-lane order. See bessel_y.

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

where P: Policy,

j_n(x), the spherical Bessel function of the first kind. See sph_bessel_j.

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

where P: Policy,

y_n(x). See sph_bessel_y.

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

where P: Policy,

i_n(x). See sph_bessel_i.

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

where P: Policy,

e^{-x} i_n(x). See sph_bessel_i_scaled.

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

where P: Policy,

k_n(x). See sph_bessel_k.

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

where P: Policy,

e^{x} k_n(x). See sph_bessel_k_scaled.

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

where P: Policy,

(j_n(x), j_n'(x)), both from one walk.

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

where P: Policy,

(y_n(x), y_n'(x)). See sph_bessel_j_with_deriv.

fn sph_bessel_i_with_deriv_n<P, const N: usize, const SCALED: bool>( self, ) -> (Self, Self)

where P: Policy,

(i_n(x), i_n'(x)), scaled by e^{-x} when SCALED, in which case the derivative is the scaled function’s own, d/dx(e^{-x} i_n) = e^{-x}(i_n' - i_n).

fn sph_bessel_k_with_deriv_n<P, const N: usize, const SCALED: bool>( self, ) -> (Self, Self)

where P: Policy,

(k_n(x), k_n'(x)), scaled by e^{x} when SCALED.

fn sph_bessel_j<P>(self, n: u32) -> Self

where P: Policy,

j_n(x) for a runtime order. See sph_bessel_j.

fn sph_bessel_y<P>(self, n: u32) -> Self

where P: Policy,

y_n(x) for a runtime order.

fn sph_bessel_i<P>(self, n: u32) -> Self

where P: Policy,

i_n(x) for a runtime order.

fn sph_bessel_i_scaled<P>(self, n: u32) -> Self

where P: Policy,

e^{-x} i_n(x) for a runtime order.

fn sph_bessel_k<P>(self, n: u32) -> Self

where P: Policy,

k_n(x) for a runtime order.

fn sph_bessel_k_scaled<P>(self, n: u32) -> Self

where P: Policy,

e^{x} k_n(x) for a runtime order.

fn sph_bessel_j_with_deriv<P>(self, n: u32) -> (Self, Self)

where P: Policy,

(j_n(x), j_n'(x)) for a runtime order. See sph_bessel_j_with_deriv_n.

fn sph_bessel_y_with_deriv<P>(self, n: u32) -> (Self, Self)

where P: Policy,

(y_n(x), y_n'(x)) for a runtime order.

fn sph_bessel_i_with_deriv<P, const SCALED: bool>(self, n: u32) -> (Self, Self)

where P: Policy,

(i_n(x), i_n'(x)) for a runtime order, scaled by e^{-x} when SCALED.

fn sph_bessel_k_with_deriv<P, const SCALED: bool>(self, n: u32) -> (Self, Self)

where P: Policy,

(k_n(x), k_n'(x)) for a runtime order, scaled by e^{x} when SCALED.

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

where P: Policy, F: BesselFamily,

bessel_n::<F, N>(): see BesselFamily.

fn bessel<P, F>(self, order: BesselOrder<Self, Self::Signed>) -> Self

where P: Policy, F: BesselFamily,

bessel::<F>(order): see BesselFamily.

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

where P: Policy, F: BesselFamily,

sph_bessel_n::<F, N>().

fn sph_bessel<P, F>(self, n: u32) -> Self

where P: Policy, F: BesselFamily,

sph_bessel::<F>(n).

fn airy<P, W>(self) -> Self

where P: Policy, W: AiryFn,

airy::<W>(): see AiryFn.

fn airy_all<P, const SCALED: bool>(self) -> (Self, Self, Self, Self)

where P: Policy,

The four Airy values, scaled on the positive axis when SCALED.

fn bessel_jv_scaled<P>(self, order: BesselOrder<Self, Self::Signed>) -> Self

where P: Policy,

Scaled(J) at runtime order: e^{-|Im z|} J_nu(z), SciPy’s jve. The scale factor is 1 on the real axis, so the default is the unscaled value. Complex overrides.

fn bessel_yv_scaled<P>(self, order: BesselOrder<Self, Self::Signed>) -> Self

where P: Policy,

Scaled(Y) at runtime order, the Y twin of bessel_jv_scaled.

fn airy_tuple<P>(self) -> (Self, Self, Self, Self)

where P: Policy,

(Ai, Ai', Bi, Bi'). See airy.

fn airy_tuple_scaled<P>(self) -> (Self, Self, Self, Self)

where P: Policy,

(Ai, Ai', Bi, Bi') with the exponential factored out on the positive axis. Not a wrapper over airy: it is the form the kernel produces natively, and the unscaled one is the wrapper. See airy with a Scaled marker.

fn airy_ai<P>(self) -> Self

where P: Policy,

Ai(x) alone: a cheaper evaluation than airy, not a projection of it. See airy_ai.

fn airy_ai_scaled<P>(self) -> Self

where P: Policy,

e^zeta Ai(x) on the positive axis. See airy_ai_scaled.

fn airy_bi<P>(self) -> Self

where P: Policy,

Bi(x) alone. See airy_bi.

fn airy_bi_scaled<P>(self) -> Self

where P: Policy,

e^-zeta Bi(x) on the positive axis. See airy_bi_scaled.

fn airy_ai_prime<P>(self) -> Self

where P: Policy,

Ai'(x) alone. See airy_ai_prime.

fn airy_ai_prime_scaled<P>(self) -> Self

where P: Policy,

e^zeta Ai'(x) on the positive axis. See airy_ai_prime_scaled.

fn airy_bi_prime<P>(self) -> Self

where P: Policy,

Bi'(x) alone. See airy_bi_prime.

fn airy_bi_prime_scaled<P>(self) -> Self

where P: Policy,

e^-zeta Bi'(x) on the positive axis. See airy_bi_prime_scaled.

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

where P: Policy,

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

where P: Policy,

fn hermite<P>(self, n: u32) -> Self

where P: Policy,

A uniform runtime degree is hermitev with the degree splatted. Nothing cheaper is correct.

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

where P: Policy,

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

where P: Policy,

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

where P: Policy,

fn hermite_function_series<P>(self, coeffs: &[Self::Element]) -> Self

where P: Policy,

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

where P: Policy,

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

where P: Policy,

fn laguerre<P>(self, alpha: Self, n: u32) -> Self

where P: Policy,

A uniform runtime degree is laguerrev with the degree splatted.

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

where P: Policy,

fn laguerre_function<P>(x: Self, alpha: Self, n: u32) -> Self

where P: Policy,

fn laguerre_function_i_n<P, const N: usize>(x: Self, alpha: i32) -> Self

where P: Policy,

fn laguerre_function_i<P>(x: Self, alpha: i32, n: u32) -> Self

where P: Policy,

fn poisson_pmf<P>(self, lambda: Self) -> Self

where P: Policy,

fn poisson_log_pmf<P>(self, lambda: Self) -> Self

where P: Policy,

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

where P: Policy,

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

where P: Policy,

fn laguerre_function_series<P>( self, alpha: Self, coeffs: &[Self::Element], ) -> Self

where P: Policy,

fn laguerre_function_series_i<P>( self, alpha: i32, coeffs: &[Self::Element], ) -> Self

where P: Policy,

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

where P: Policy,

fn chebyshev_n<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 lbeta<P>(a: Self, b: Self) -> Self

where P: Policy,

fn logit<P>(self) -> Self

where P: Policy,

fn logit_1m<P>(self) -> Self

where P: Policy,

fn planck<P>(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,

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

where P: Policy,

fn legendre_series<P>(self, coeffs: &[Self::Element]) -> Self

where P: Policy,

fn zernike_r<P>(rho: Self, n: u32, m: u32) -> Self

where P: Policy,

fn zernike<P, const NORM: u8>(rho: Self, theta: Self, n: u32, m: i32) -> Self

where P: Policy,

fn zernike_basis<P, const L: usize, const NORM: u8, const N: usize>( x: Self, y: Self, out: &mut [Self; N], )

where P: Policy,

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

where P: Policy,

fn phi<P>(self, n: u32) -> Self

where P: Policy,

The runtime-order twin of phi_n. The f32/f64 backends override it with a term count worked out from n per call.

impl<V> SpecializedTranscendentalMath<Compensated<<V as GenericVector>::Element>> for Compensated<V>

where V: RealMathWithPolicy + CompensatedFloatVector,

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

$(\sin \pi x, \cos \pi x)$, reducing before multiplying by pi.

The inherited default is sin_cos(self * PI), which throws away most of what this type exists for. Forming x * PI rounds the product, so the argument handed to sin_cos already carries an absolute error of about |x| * 2^-106; at x = -1000.5 (an ordinary argument for the gamma reflection) that is three or four digits gone before any trigonometry happens.

Reducing first avoids it entirely. sin(pi(n + r)) = (-1)^n sin(pi r) for integer n, and x - round(x) is exact, so the only rounded product is r * PI with |r| <= 1/2. Same for cosine, with the same sign flip.

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

atanh(x)/x, the cardinal form of atanh: same structure as sinc below, with the even series 1 + x^2/3 + x^4/5. Domain [-1, 1], where both ends are +inf.

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

sinh(x)/x, the hyperbolic twin of sinc above and structurally identical to it: the series 1 + x^2/6 + x^4/120 adds where sinc subtracts, and the limit at infinity is +inf rather than zero.

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

The _ext form exists so a caller who already has ln(x) can hand it to the low-precision approximation instead of paying for it twice. The compensated path never takes that approximation (it evaluates ln(1 - e^-x) exactly), so there is nothing to reuse and the hint is dropped, the same way the f64 kernel (math/specialized/pd.rs) and Complex do.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn log_n<P: Policy>(self, n: u32) -> Self

The runtime twin of log_n_n. This default goes through log. The real f32/f64 vectors override it with the same table lookup the const form uses, so the two agree to the bit there.

fn sin<P>(self) -> Self

where P: Policy,

fn cos<P>(self) -> Self

where P: Policy,

fn tan<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 sinc_pi<P>(self) -> Self

where P: Policy,

fn xlog_guarded(x: Self, y: Self, ln_y: Self) -> Self

x * ln_of_y, with x == 0 winning over an infinite log but a NaN y winning over both. Shared by xlogy, xlog1py and entr; the other two members of the family guard on the sign of both arguments instead and cannot use it.

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

where P: Policy,

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

where P: Policy,

fn cosh_m1<P>(self) -> Self

where P: Policy,

cosh(x) - 1 = 2 sinh^2(x/2), an exact identity, so no type needs to override this: the composition inherits whatever accuracy that type’s sinh has, and near zero sinh(x/2) is already x/2 to full relative precision, giving x^2/2 with no cancellation anywhere. Same treatment as versin above.

fn sqrt1pm1<P>(self) -> Self

where P: Policy,

fn sqrt1mexp<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 compound_m1<P>(self, n: Self) -> Self

where P: Policy,

fn haversin<P>(self) -> Self

where P: Policy,

fn versin<P>(self) -> Self

where P: Policy,

fn versinc<P>(self) -> Self

where P: Policy,

fn cos_m1<P>(self) -> Self

where P: Policy,

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

where P: Policy,

fn nth_root<P>(self, n: u32) -> Self

where P: Policy,

The runtime twin of nth_root_n: the same arithmetic with the degree as a value, so the two agree to the bit at every n. The special cases are one uniform branch on n rather than a compile-time fold.

fn log2_p1<P>(self) -> Self

where P: Policy,

fn log10_p1<P>(self) -> Self

where P: Policy,

fn log1pmx<P>(self) -> Self

where P: Policy,

The direct form, which cancels near zero (see the trait method’s docs). Real f32/f64 vectors override this with generic::log1pmx_internal. The default exists so that ordered-comparison-free types (Complex above all, which cannot select a window at all) still get a correct answer rather than blocking the whole method.

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: CompensatedFloatVector> SplatVector<Compensated<<V as GenericVector>::Element>> for Compensated<V>

type Splat<T: SplatConst<Compensated<V::Element>>> = Compensated<V>

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

impl<V: ScalarValue> Square for Compensated<V>

type Output = Compensated<V>

The squared value. Not always Self: a type may widen to hold the product.

fn square(self) -> Self

Computes self * self.

impl<V: CompensatedFloatVector> SquareMasked<<V as GenericVector>::Mask> for Compensated<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 Compensated<V>

impl<V: ScalarValue> Sub for Compensated<V>

type Output = Compensated<V>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<V: ScalarValue> Sub<V> for Compensated<V>

type Output = Compensated<V>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<V: Copy, T> SubAssign<T> for Compensated<V>

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

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<V: CompensatedFloatVector, Rhs> SubAssignMasked<<V as GenericVector>::Mask, Rhs> for Compensated<V>

where Compensated<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: CompensatedFloatVector, Rhs> SubMasked<<V as GenericVector>::Mask, Rhs> for Compensated<V>

where Compensated<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: ScalarValue> Sum for Compensated<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: CompensatedFloatVector> Swizzle<<V as GenericVector>::Lanes> for Compensated<V>

fn swizzle_const<I: SwizzleIndices<V::Lanes>>(self, other: Self) -> Self

Swizzle lanes from two vectors according to compile-time indices.

fn permutev_const<I: SwizzleIndices<V::Lanes>>(self) -> Self

Permute lanes of a single vector according to compile-time indices.

impl<V: CompensatedFloatVector, E: SplatConst<Compensated<V::Element>>> VectorValue<E, Compensated<V>> for Compensated<V>

const VALUE: Compensated<V>

The materialized vector constant.