Trait MulAddExtMasked 

pub trait MulAddExtMasked<Mask, A = Self, B = Self>: MulAddExt<A, B> {
    // Required methods
    fn mul_add_c(self, mask: Mask, a: A, b: B) -> Self::Output;
    fn mul_add_m(self, src: Self, mask: Mask, a: A, b: B) -> Self::Output;
    fn mul_add_z(self, mask: Mask, a: A, b: B) -> Self::Output;
    fn mul_sub_c(self, mask: Mask, a: A, b: B) -> Self::Output;
    fn mul_sub_m(self, src: Self, mask: Mask, a: A, b: B) -> Self::Output;
    fn mul_sub_z(self, mask: Mask, a: A, b: B) -> Self::Output;
    fn nmul_add_c(self, mask: Mask, a: A, b: B) -> Self::Output;
    fn nmul_add_m(self, src: Self, mask: Mask, a: A, b: B) -> Self::Output;
    fn nmul_add_z(self, mask: Mask, a: A, b: B) -> Self::Output;
    fn nmul_sub_c(self, mask: Mask, a: A, b: B) -> Self::Output;
    fn nmul_sub_m(self, src: Self, mask: Mask, a: A, b: B) -> Self::Output;
    fn nmul_sub_z(self, mask: Mask, a: A, b: B) -> Self::Output;
    fn mul_adde_c(self, mask: Mask, a: A, b: B) -> Self::Output;
    fn mul_adde_m(self, src: Self, mask: Mask, a: A, b: B) -> Self::Output;
    fn mul_adde_z(self, mask: Mask, a: A, b: B) -> Self::Output;
    fn mul_sube_c(self, mask: Mask, a: A, b: B) -> Self::Output;
    fn mul_sube_m(self, src: Self, mask: Mask, a: A, b: B) -> Self::Output;
    fn mul_sube_z(self, mask: Mask, a: A, b: B) -> Self::Output;
    fn nmul_adde_c(self, mask: Mask, a: A, b: B) -> Self::Output;
    fn nmul_adde_m(self, src: Self, mask: Mask, a: A, b: B) -> Self::Output;
    fn nmul_adde_z(self, mask: Mask, a: A, b: B) -> Self::Output;
    fn nmul_sube_c(self, mask: Mask, a: A, b: B) -> Self::Output;
    fn nmul_sube_m(self, src: Self, mask: Mask, a: A, b: B) -> Self::Output;
    fn nmul_sube_z(self, mask: Mask, a: A, b: B) -> Self::Output;
}

Provides masked variants of the fused multiply-add operations from MulAddExt.

Required Methods

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

Guaranteed fused-multiply-add operation.

If the target architecture does not support native FMA, this will use either compensated arithmetic or slow scalar evaluation to ensure correctness.

This variant computes mul_add with a and b where mask is true.

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

Guaranteed fused-multiply-add operation.

If the target architecture does not support native FMA, this will use either compensated arithmetic or slow scalar evaluation to ensure correctness.

This variant merges mul_add with src using mask, returning src where mask is false.

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

Guaranteed fused-multiply-add operation.

If the target architecture does not support native FMA, this will use either compensated arithmetic or slow scalar evaluation to ensure correctness.

This variant computes mul_add masked (zeroed where mask is false).

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

Guaranteed fused-multiply-subtract operation.

If the target architecture does not support native FMA, this will use either compensated arithmetic or slow scalar evaluation to ensure correctness.

This variant computes mul_sub with a and b where mask is true.

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

Guaranteed fused-multiply-subtract operation.

If the target architecture does not support native FMA, this will use either compensated arithmetic or slow scalar evaluation to ensure correctness.

This variant merges mul_sub with src using mask, returning src where mask is false.

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

Guaranteed fused-multiply-subtract operation.

If the target architecture does not support native FMA, this will use either compensated arithmetic or slow scalar evaluation to ensure correctness.

This variant computes mul_sub masked (zeroed where mask is false).

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

Guaranteed fused-negated-multiply-add operation.

If the target architecture does not support native FMA, this will use either compensated arithmetic or slow scalar evaluation to ensure correctness.

This variant computes nmul_add with a and b where mask is true.

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

Guaranteed fused-negated-multiply-add operation.

If the target architecture does not support native FMA, this will use either compensated arithmetic or slow scalar evaluation to ensure correctness.

This variant merges nmul_add with src using mask, returning src where mask is false.

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

Guaranteed fused-negated-multiply-add operation.

If the target architecture does not support native FMA, this will use either compensated arithmetic or slow scalar evaluation to ensure correctness.

This variant computes nmul_add masked (zeroed where mask is false).

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

Guaranteed fused-negated-multiply-subtract operation.

If the target architecture does not support native FMA, this will use either compensated arithmetic or slow scalar evaluation to ensure correctness.

This variant computes nmul_sub with a and b where mask is true.

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

Guaranteed fused-negated-multiply-subtract operation.

If the target architecture does not support native FMA, this will use either compensated arithmetic or slow scalar evaluation to ensure correctness.

This variant merges nmul_sub with src using mask, returning src where mask is false.

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

Guaranteed fused-negated-multiply-subtract operation.

If the target architecture does not support native FMA, this will use either compensated arithmetic or slow scalar evaluation to ensure correctness.

This variant computes nmul_sub masked (zeroed where mask is false).

fn mul_adde_c(self, mask: Mask, a: A, b: B) -> 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.

This variant computes mul_adde with a and b where mask is true.

fn mul_adde_m(self, src: Self, mask: Mask, a: A, b: B) -> 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.

This variant merges mul_adde with src using mask, returning src where mask is false.

fn mul_adde_z(self, mask: Mask, a: A, b: B) -> 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.

This variant computes mul_adde masked (zeroed where mask is false).

fn mul_sube_c(self, mask: Mask, a: A, b: B) -> 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.

This variant computes mul_sube with a and b where mask is true.

fn mul_sube_m(self, src: Self, mask: Mask, a: A, b: B) -> 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.

This variant merges mul_sube with src using mask, returning src where mask is false.

fn mul_sube_z(self, mask: Mask, a: A, b: B) -> 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.

This variant computes mul_sube masked (zeroed where mask is false).

fn nmul_adde_c(self, mask: Mask, a: A, b: B) -> 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.

This variant computes nmul_adde with a and b where mask is true.

fn nmul_adde_m(self, src: Self, mask: Mask, a: A, b: B) -> 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.

This variant merges nmul_adde with src using mask, returning src where mask is false.

fn nmul_adde_z(self, mask: Mask, a: A, b: B) -> 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.

This variant computes nmul_adde masked (zeroed where mask is false).

fn nmul_sube_c(self, mask: Mask, a: A, b: B) -> 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.

This variant computes nmul_sube with a and b where mask is true.

fn nmul_sube_m(self, src: Self, mask: Mask, a: A, b: B) -> 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.

This variant merges nmul_sube with src using mask, returning src where mask is false.

fn nmul_sube_z(self, mask: Mask, a: A, b: B) -> 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.

This variant computes nmul_sube masked (zeroed where mask is false).

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<R: FloatRegister> MulAddExtMasked<Mask<R>> for Vector<R>