Trait vek::ops::MulAdd

pub trait MulAdd<MulRhs = Self, AddRhs = Self> {
    type Output;
    fn mul_add(self, mul: MulRhs, add: AddRhs) -> Self::Output;
}

The fused multiply-add operation.

Associated Types

type Output

The resulting type after applying the fused multiply-add operation.

Loading content...

Required methods

fn mul_add(self, mul: MulRhs, add: AddRhs) -> Self::Output

Returns (self * mul) + add as a possibly faster and more precise single operation.

Loading content...

Implementations on Foreign Types

impl MulAdd<f32, f32> for f32

type Output = f32

fn mul_add(self, mul: f32, add: f32) -> Self::Output

impl<'c> MulAdd<f32, &'c f32> for f32

type Output = f32

fn mul_add(self, mul: f32, add: &'c f32) -> Self::Output

impl<'b> MulAdd<&'b f32, f32> for f32

type Output = f32

fn mul_add(self, mul: &'b f32, add: f32) -> Self::Output

impl<'b, 'c> MulAdd<&'b f32, &'c f32> for f32

type Output = f32

fn mul_add(self, mul: &'b f32, add: &'c f32) -> Self::Output

impl<'a> MulAdd<f32, f32> for &'a f32

type Output = f32

fn mul_add(self, mul: f32, add: f32) -> Self::Output

impl<'a, 'c> MulAdd<f32, &'c f32> for &'a f32

type Output = f32

fn mul_add(self, mul: f32, add: &'c f32) -> Self::Output

impl<'a, 'b> MulAdd<&'b f32, f32> for &'a f32

type Output = f32

fn mul_add(self, mul: &'b f32, add: f32) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b f32, &'c f32> for &'a f32

type Output = f32

fn mul_add(self, mul: &'b f32, add: &'c f32) -> Self::Output

impl MulAdd<f64, f64> for f64

type Output = f64

fn mul_add(self, mul: f64, add: f64) -> Self::Output

impl<'c> MulAdd<f64, &'c f64> for f64

type Output = f64

fn mul_add(self, mul: f64, add: &'c f64) -> Self::Output

impl<'b> MulAdd<&'b f64, f64> for f64

type Output = f64

fn mul_add(self, mul: &'b f64, add: f64) -> Self::Output

impl<'b, 'c> MulAdd<&'b f64, &'c f64> for f64

type Output = f64

fn mul_add(self, mul: &'b f64, add: &'c f64) -> Self::Output

impl<'a> MulAdd<f64, f64> for &'a f64

type Output = f64

fn mul_add(self, mul: f64, add: f64) -> Self::Output

impl<'a, 'c> MulAdd<f64, &'c f64> for &'a f64

type Output = f64

fn mul_add(self, mul: f64, add: &'c f64) -> Self::Output

impl<'a, 'b> MulAdd<&'b f64, f64> for &'a f64

type Output = f64

fn mul_add(self, mul: &'b f64, add: f64) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b f64, &'c f64> for &'a f64

type Output = f64

fn mul_add(self, mul: &'b f64, add: &'c f64) -> Self::Output

impl MulAdd<i8, i8> for i8

type Output = i8

fn mul_add(self, mul: i8, add: i8) -> Self::Output

impl<'c> MulAdd<i8, &'c i8> for i8

type Output = i8

fn mul_add(self, mul: i8, add: &'c i8) -> Self::Output

impl<'b> MulAdd<&'b i8, i8> for i8

type Output = i8

fn mul_add(self, mul: &'b i8, add: i8) -> Self::Output

impl<'b, 'c> MulAdd<&'b i8, &'c i8> for i8

type Output = i8

fn mul_add(self, mul: &'b i8, add: &'c i8) -> Self::Output

impl<'a> MulAdd<i8, i8> for &'a i8

type Output = i8

fn mul_add(self, mul: i8, add: i8) -> Self::Output

impl<'a, 'c> MulAdd<i8, &'c i8> for &'a i8

type Output = i8

fn mul_add(self, mul: i8, add: &'c i8) -> Self::Output

impl<'a, 'b> MulAdd<&'b i8, i8> for &'a i8

type Output = i8

fn mul_add(self, mul: &'b i8, add: i8) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b i8, &'c i8> for &'a i8

type Output = i8

fn mul_add(self, mul: &'b i8, add: &'c i8) -> Self::Output

impl MulAdd<i16, i16> for i16

type Output = i16

fn mul_add(self, mul: i16, add: i16) -> Self::Output

impl<'c> MulAdd<i16, &'c i16> for i16

type Output = i16

fn mul_add(self, mul: i16, add: &'c i16) -> Self::Output

impl<'b> MulAdd<&'b i16, i16> for i16

type Output = i16

fn mul_add(self, mul: &'b i16, add: i16) -> Self::Output

impl<'b, 'c> MulAdd<&'b i16, &'c i16> for i16

type Output = i16

fn mul_add(self, mul: &'b i16, add: &'c i16) -> Self::Output

impl<'a> MulAdd<i16, i16> for &'a i16

type Output = i16

fn mul_add(self, mul: i16, add: i16) -> Self::Output

impl<'a, 'c> MulAdd<i16, &'c i16> for &'a i16

type Output = i16

fn mul_add(self, mul: i16, add: &'c i16) -> Self::Output

impl<'a, 'b> MulAdd<&'b i16, i16> for &'a i16

type Output = i16

fn mul_add(self, mul: &'b i16, add: i16) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b i16, &'c i16> for &'a i16

type Output = i16

fn mul_add(self, mul: &'b i16, add: &'c i16) -> Self::Output

impl MulAdd<i32, i32> for i32

type Output = i32

fn mul_add(self, mul: i32, add: i32) -> Self::Output

impl<'c> MulAdd<i32, &'c i32> for i32

type Output = i32

fn mul_add(self, mul: i32, add: &'c i32) -> Self::Output

impl<'b> MulAdd<&'b i32, i32> for i32

type Output = i32

fn mul_add(self, mul: &'b i32, add: i32) -> Self::Output

impl<'b, 'c> MulAdd<&'b i32, &'c i32> for i32

type Output = i32

fn mul_add(self, mul: &'b i32, add: &'c i32) -> Self::Output

impl<'a> MulAdd<i32, i32> for &'a i32

type Output = i32

fn mul_add(self, mul: i32, add: i32) -> Self::Output

impl<'a, 'c> MulAdd<i32, &'c i32> for &'a i32

type Output = i32

fn mul_add(self, mul: i32, add: &'c i32) -> Self::Output

impl<'a, 'b> MulAdd<&'b i32, i32> for &'a i32

type Output = i32

fn mul_add(self, mul: &'b i32, add: i32) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b i32, &'c i32> for &'a i32

type Output = i32

fn mul_add(self, mul: &'b i32, add: &'c i32) -> Self::Output

impl MulAdd<i64, i64> for i64

type Output = i64

fn mul_add(self, mul: i64, add: i64) -> Self::Output

impl<'c> MulAdd<i64, &'c i64> for i64

type Output = i64

fn mul_add(self, mul: i64, add: &'c i64) -> Self::Output

impl<'b> MulAdd<&'b i64, i64> for i64

type Output = i64

fn mul_add(self, mul: &'b i64, add: i64) -> Self::Output

impl<'b, 'c> MulAdd<&'b i64, &'c i64> for i64

type Output = i64

fn mul_add(self, mul: &'b i64, add: &'c i64) -> Self::Output

impl<'a> MulAdd<i64, i64> for &'a i64

type Output = i64

fn mul_add(self, mul: i64, add: i64) -> Self::Output

impl<'a, 'c> MulAdd<i64, &'c i64> for &'a i64

type Output = i64

fn mul_add(self, mul: i64, add: &'c i64) -> Self::Output

impl<'a, 'b> MulAdd<&'b i64, i64> for &'a i64

type Output = i64

fn mul_add(self, mul: &'b i64, add: i64) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b i64, &'c i64> for &'a i64

type Output = i64

fn mul_add(self, mul: &'b i64, add: &'c i64) -> Self::Output

impl MulAdd<isize, isize> for isize

type Output = isize

fn mul_add(self, mul: isize, add: isize) -> Self::Output

impl<'c> MulAdd<isize, &'c isize> for isize

type Output = isize

fn mul_add(self, mul: isize, add: &'c isize) -> Self::Output

impl<'b> MulAdd<&'b isize, isize> for isize

type Output = isize

fn mul_add(self, mul: &'b isize, add: isize) -> Self::Output

impl<'b, 'c> MulAdd<&'b isize, &'c isize> for isize

type Output = isize

fn mul_add(self, mul: &'b isize, add: &'c isize) -> Self::Output

impl<'a> MulAdd<isize, isize> for &'a isize

type Output = isize

fn mul_add(self, mul: isize, add: isize) -> Self::Output

impl<'a, 'c> MulAdd<isize, &'c isize> for &'a isize

type Output = isize

fn mul_add(self, mul: isize, add: &'c isize) -> Self::Output

impl<'a, 'b> MulAdd<&'b isize, isize> for &'a isize

type Output = isize

fn mul_add(self, mul: &'b isize, add: isize) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b isize, &'c isize> for &'a isize

type Output = isize

fn mul_add(self, mul: &'b isize, add: &'c isize) -> Self::Output

impl MulAdd<u8, u8> for u8

type Output = u8

fn mul_add(self, mul: u8, add: u8) -> Self::Output

impl<'c> MulAdd<u8, &'c u8> for u8

type Output = u8

fn mul_add(self, mul: u8, add: &'c u8) -> Self::Output

impl<'b> MulAdd<&'b u8, u8> for u8

type Output = u8

fn mul_add(self, mul: &'b u8, add: u8) -> Self::Output

impl<'b, 'c> MulAdd<&'b u8, &'c u8> for u8

type Output = u8

fn mul_add(self, mul: &'b u8, add: &'c u8) -> Self::Output

impl<'a> MulAdd<u8, u8> for &'a u8

type Output = u8

fn mul_add(self, mul: u8, add: u8) -> Self::Output

impl<'a, 'c> MulAdd<u8, &'c u8> for &'a u8

type Output = u8

fn mul_add(self, mul: u8, add: &'c u8) -> Self::Output

impl<'a, 'b> MulAdd<&'b u8, u8> for &'a u8

type Output = u8

fn mul_add(self, mul: &'b u8, add: u8) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b u8, &'c u8> for &'a u8

type Output = u8

fn mul_add(self, mul: &'b u8, add: &'c u8) -> Self::Output

impl MulAdd<u16, u16> for u16

type Output = u16

fn mul_add(self, mul: u16, add: u16) -> Self::Output

impl<'c> MulAdd<u16, &'c u16> for u16

type Output = u16

fn mul_add(self, mul: u16, add: &'c u16) -> Self::Output

impl<'b> MulAdd<&'b u16, u16> for u16

type Output = u16

fn mul_add(self, mul: &'b u16, add: u16) -> Self::Output

impl<'b, 'c> MulAdd<&'b u16, &'c u16> for u16

type Output = u16

fn mul_add(self, mul: &'b u16, add: &'c u16) -> Self::Output

impl<'a> MulAdd<u16, u16> for &'a u16

type Output = u16

fn mul_add(self, mul: u16, add: u16) -> Self::Output

impl<'a, 'c> MulAdd<u16, &'c u16> for &'a u16

type Output = u16

fn mul_add(self, mul: u16, add: &'c u16) -> Self::Output

impl<'a, 'b> MulAdd<&'b u16, u16> for &'a u16

type Output = u16

fn mul_add(self, mul: &'b u16, add: u16) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b u16, &'c u16> for &'a u16

type Output = u16

fn mul_add(self, mul: &'b u16, add: &'c u16) -> Self::Output

impl MulAdd<u32, u32> for u32

type Output = u32

fn mul_add(self, mul: u32, add: u32) -> Self::Output

impl<'c> MulAdd<u32, &'c u32> for u32

type Output = u32

fn mul_add(self, mul: u32, add: &'c u32) -> Self::Output

impl<'b> MulAdd<&'b u32, u32> for u32

type Output = u32

fn mul_add(self, mul: &'b u32, add: u32) -> Self::Output

impl<'b, 'c> MulAdd<&'b u32, &'c u32> for u32

type Output = u32

fn mul_add(self, mul: &'b u32, add: &'c u32) -> Self::Output

impl<'a> MulAdd<u32, u32> for &'a u32

type Output = u32

fn mul_add(self, mul: u32, add: u32) -> Self::Output

impl<'a, 'c> MulAdd<u32, &'c u32> for &'a u32

type Output = u32

fn mul_add(self, mul: u32, add: &'c u32) -> Self::Output

impl<'a, 'b> MulAdd<&'b u32, u32> for &'a u32

type Output = u32

fn mul_add(self, mul: &'b u32, add: u32) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b u32, &'c u32> for &'a u32

type Output = u32

fn mul_add(self, mul: &'b u32, add: &'c u32) -> Self::Output

impl MulAdd<u64, u64> for u64

type Output = u64

fn mul_add(self, mul: u64, add: u64) -> Self::Output

impl<'c> MulAdd<u64, &'c u64> for u64

type Output = u64

fn mul_add(self, mul: u64, add: &'c u64) -> Self::Output

impl<'b> MulAdd<&'b u64, u64> for u64

type Output = u64

fn mul_add(self, mul: &'b u64, add: u64) -> Self::Output

impl<'b, 'c> MulAdd<&'b u64, &'c u64> for u64

type Output = u64

fn mul_add(self, mul: &'b u64, add: &'c u64) -> Self::Output

impl<'a> MulAdd<u64, u64> for &'a u64

type Output = u64

fn mul_add(self, mul: u64, add: u64) -> Self::Output

impl<'a, 'c> MulAdd<u64, &'c u64> for &'a u64

type Output = u64

fn mul_add(self, mul: u64, add: &'c u64) -> Self::Output

impl<'a, 'b> MulAdd<&'b u64, u64> for &'a u64

type Output = u64

fn mul_add(self, mul: &'b u64, add: u64) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b u64, &'c u64> for &'a u64

type Output = u64

fn mul_add(self, mul: &'b u64, add: &'c u64) -> Self::Output

impl MulAdd<usize, usize> for usize

type Output = usize

fn mul_add(self, mul: usize, add: usize) -> Self::Output

impl<'c> MulAdd<usize, &'c usize> for usize

type Output = usize

fn mul_add(self, mul: usize, add: &'c usize) -> Self::Output

impl<'b> MulAdd<&'b usize, usize> for usize

type Output = usize

fn mul_add(self, mul: &'b usize, add: usize) -> Self::Output

impl<'b, 'c> MulAdd<&'b usize, &'c usize> for usize

type Output = usize

fn mul_add(self, mul: &'b usize, add: &'c usize) -> Self::Output

impl<'a> MulAdd<usize, usize> for &'a usize

type Output = usize

fn mul_add(self, mul: usize, add: usize) -> Self::Output

impl<'a, 'c> MulAdd<usize, &'c usize> for &'a usize

type Output = usize

fn mul_add(self, mul: usize, add: &'c usize) -> Self::Output

impl<'a, 'b> MulAdd<&'b usize, usize> for &'a usize

type Output = usize

fn mul_add(self, mul: &'b usize, add: usize) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b usize, &'c usize> for &'a usize

type Output = usize

fn mul_add(self, mul: &'b usize, add: &'c usize) -> Self::Output

impl MulAdd<Wrapping<i8>, Wrapping<i8>> for Wrapping<i8>

type Output = Wrapping<i8>

fn mul_add(self, mul: Wrapping<i8>, add: Wrapping<i8>) -> Self::Output

impl<'c> MulAdd<Wrapping<i8>, &'c Wrapping<i8>> for Wrapping<i8>

type Output = Wrapping<i8>

fn mul_add(self, mul: Wrapping<i8>, add: &'c Wrapping<i8>) -> Self::Output

impl<'b> MulAdd<&'b Wrapping<i8>, Wrapping<i8>> for Wrapping<i8>

type Output = Wrapping<i8>

fn mul_add(self, mul: &'b Wrapping<i8>, add: Wrapping<i8>) -> Self::Output

impl<'b, 'c> MulAdd<&'b Wrapping<i8>, &'c Wrapping<i8>> for Wrapping<i8>

type Output = Wrapping<i8>

fn mul_add(self, mul: &'b Wrapping<i8>, add: &'c Wrapping<i8>) -> Self::Output

impl<'a> MulAdd<Wrapping<i8>, Wrapping<i8>> for &'a Wrapping<i8>

type Output = Wrapping<i8>

fn mul_add(self, mul: Wrapping<i8>, add: Wrapping<i8>) -> Self::Output

impl<'a, 'c> MulAdd<Wrapping<i8>, &'c Wrapping<i8>> for &'a Wrapping<i8>

type Output = Wrapping<i8>

fn mul_add(self, mul: Wrapping<i8>, add: &'c Wrapping<i8>) -> Self::Output

impl<'a, 'b> MulAdd<&'b Wrapping<i8>, Wrapping<i8>> for &'a Wrapping<i8>

type Output = Wrapping<i8>

fn mul_add(self, mul: &'b Wrapping<i8>, add: Wrapping<i8>) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b Wrapping<i8>, &'c Wrapping<i8>> for &'a Wrapping<i8>

type Output = Wrapping<i8>

fn mul_add(self, mul: &'b Wrapping<i8>, add: &'c Wrapping<i8>) -> Self::Output

impl MulAdd<Wrapping<i16>, Wrapping<i16>> for Wrapping<i16>

type Output = Wrapping<i16>

fn mul_add(self, mul: Wrapping<i16>, add: Wrapping<i16>) -> Self::Output

impl<'c> MulAdd<Wrapping<i16>, &'c Wrapping<i16>> for Wrapping<i16>

type Output = Wrapping<i16>

fn mul_add(self, mul: Wrapping<i16>, add: &'c Wrapping<i16>) -> Self::Output

impl<'b> MulAdd<&'b Wrapping<i16>, Wrapping<i16>> for Wrapping<i16>

type Output = Wrapping<i16>

fn mul_add(self, mul: &'b Wrapping<i16>, add: Wrapping<i16>) -> Self::Output

impl<'b, 'c> MulAdd<&'b Wrapping<i16>, &'c Wrapping<i16>> for Wrapping<i16>

type Output = Wrapping<i16>

fn mul_add(self, mul: &'b Wrapping<i16>, add: &'c Wrapping<i16>) -> Self::Output

impl<'a> MulAdd<Wrapping<i16>, Wrapping<i16>> for &'a Wrapping<i16>

type Output = Wrapping<i16>

fn mul_add(self, mul: Wrapping<i16>, add: Wrapping<i16>) -> Self::Output

impl<'a, 'c> MulAdd<Wrapping<i16>, &'c Wrapping<i16>> for &'a Wrapping<i16>

type Output = Wrapping<i16>

fn mul_add(self, mul: Wrapping<i16>, add: &'c Wrapping<i16>) -> Self::Output

impl<'a, 'b> MulAdd<&'b Wrapping<i16>, Wrapping<i16>> for &'a Wrapping<i16>

type Output = Wrapping<i16>

fn mul_add(self, mul: &'b Wrapping<i16>, add: Wrapping<i16>) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b Wrapping<i16>, &'c Wrapping<i16>> for &'a Wrapping<i16>

type Output = Wrapping<i16>

fn mul_add(self, mul: &'b Wrapping<i16>, add: &'c Wrapping<i16>) -> Self::Output

impl MulAdd<Wrapping<i32>, Wrapping<i32>> for Wrapping<i32>

type Output = Wrapping<i32>

fn mul_add(self, mul: Wrapping<i32>, add: Wrapping<i32>) -> Self::Output

impl<'c> MulAdd<Wrapping<i32>, &'c Wrapping<i32>> for Wrapping<i32>

type Output = Wrapping<i32>

fn mul_add(self, mul: Wrapping<i32>, add: &'c Wrapping<i32>) -> Self::Output

impl<'b> MulAdd<&'b Wrapping<i32>, Wrapping<i32>> for Wrapping<i32>

type Output = Wrapping<i32>

fn mul_add(self, mul: &'b Wrapping<i32>, add: Wrapping<i32>) -> Self::Output

impl<'b, 'c> MulAdd<&'b Wrapping<i32>, &'c Wrapping<i32>> for Wrapping<i32>

type Output = Wrapping<i32>

fn mul_add(self, mul: &'b Wrapping<i32>, add: &'c Wrapping<i32>) -> Self::Output

impl<'a> MulAdd<Wrapping<i32>, Wrapping<i32>> for &'a Wrapping<i32>

type Output = Wrapping<i32>

fn mul_add(self, mul: Wrapping<i32>, add: Wrapping<i32>) -> Self::Output

impl<'a, 'c> MulAdd<Wrapping<i32>, &'c Wrapping<i32>> for &'a Wrapping<i32>

type Output = Wrapping<i32>

fn mul_add(self, mul: Wrapping<i32>, add: &'c Wrapping<i32>) -> Self::Output

impl<'a, 'b> MulAdd<&'b Wrapping<i32>, Wrapping<i32>> for &'a Wrapping<i32>

type Output = Wrapping<i32>

fn mul_add(self, mul: &'b Wrapping<i32>, add: Wrapping<i32>) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b Wrapping<i32>, &'c Wrapping<i32>> for &'a Wrapping<i32>

type Output = Wrapping<i32>

fn mul_add(self, mul: &'b Wrapping<i32>, add: &'c Wrapping<i32>) -> Self::Output

impl MulAdd<Wrapping<i64>, Wrapping<i64>> for Wrapping<i64>

type Output = Wrapping<i64>

fn mul_add(self, mul: Wrapping<i64>, add: Wrapping<i64>) -> Self::Output

impl<'c> MulAdd<Wrapping<i64>, &'c Wrapping<i64>> for Wrapping<i64>

type Output = Wrapping<i64>

fn mul_add(self, mul: Wrapping<i64>, add: &'c Wrapping<i64>) -> Self::Output

impl<'b> MulAdd<&'b Wrapping<i64>, Wrapping<i64>> for Wrapping<i64>

type Output = Wrapping<i64>

fn mul_add(self, mul: &'b Wrapping<i64>, add: Wrapping<i64>) -> Self::Output

impl<'b, 'c> MulAdd<&'b Wrapping<i64>, &'c Wrapping<i64>> for Wrapping<i64>

type Output = Wrapping<i64>

fn mul_add(self, mul: &'b Wrapping<i64>, add: &'c Wrapping<i64>) -> Self::Output

impl<'a> MulAdd<Wrapping<i64>, Wrapping<i64>> for &'a Wrapping<i64>

type Output = Wrapping<i64>

fn mul_add(self, mul: Wrapping<i64>, add: Wrapping<i64>) -> Self::Output

impl<'a, 'c> MulAdd<Wrapping<i64>, &'c Wrapping<i64>> for &'a Wrapping<i64>

type Output = Wrapping<i64>

fn mul_add(self, mul: Wrapping<i64>, add: &'c Wrapping<i64>) -> Self::Output

impl<'a, 'b> MulAdd<&'b Wrapping<i64>, Wrapping<i64>> for &'a Wrapping<i64>

type Output = Wrapping<i64>

fn mul_add(self, mul: &'b Wrapping<i64>, add: Wrapping<i64>) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b Wrapping<i64>, &'c Wrapping<i64>> for &'a Wrapping<i64>

type Output = Wrapping<i64>

fn mul_add(self, mul: &'b Wrapping<i64>, add: &'c Wrapping<i64>) -> Self::Output

impl MulAdd<Wrapping<isize>, Wrapping<isize>> for Wrapping<isize>

type Output = Wrapping<isize>

fn mul_add(self, mul: Wrapping<isize>, add: Wrapping<isize>) -> Self::Output

impl<'c> MulAdd<Wrapping<isize>, &'c Wrapping<isize>> for Wrapping<isize>

type Output = Wrapping<isize>

fn mul_add(self, mul: Wrapping<isize>, add: &'c Wrapping<isize>) -> Self::Output

impl<'b> MulAdd<&'b Wrapping<isize>, Wrapping<isize>> for Wrapping<isize>

type Output = Wrapping<isize>

fn mul_add(self, mul: &'b Wrapping<isize>, add: Wrapping<isize>) -> Self::Output

impl<'b, 'c> MulAdd<&'b Wrapping<isize>, &'c Wrapping<isize>> for Wrapping<isize>

type Output = Wrapping<isize>

fn mul_add(
    self,
    mul: &'b Wrapping<isize>,
    add: &'c Wrapping<isize>
) -> Self::Output

impl<'a> MulAdd<Wrapping<isize>, Wrapping<isize>> for &'a Wrapping<isize>

type Output = Wrapping<isize>

fn mul_add(self, mul: Wrapping<isize>, add: Wrapping<isize>) -> Self::Output

impl<'a, 'c> MulAdd<Wrapping<isize>, &'c Wrapping<isize>> for &'a Wrapping<isize>

type Output = Wrapping<isize>

fn mul_add(self, mul: Wrapping<isize>, add: &'c Wrapping<isize>) -> Self::Output

impl<'a, 'b> MulAdd<&'b Wrapping<isize>, Wrapping<isize>> for &'a Wrapping<isize>

type Output = Wrapping<isize>

fn mul_add(self, mul: &'b Wrapping<isize>, add: Wrapping<isize>) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b Wrapping<isize>, &'c Wrapping<isize>> for &'a Wrapping<isize>

type Output = Wrapping<isize>

fn mul_add(
    self,
    mul: &'b Wrapping<isize>,
    add: &'c Wrapping<isize>
) -> Self::Output

impl MulAdd<Wrapping<u8>, Wrapping<u8>> for Wrapping<u8>

type Output = Wrapping<u8>

fn mul_add(self, mul: Wrapping<u8>, add: Wrapping<u8>) -> Self::Output

impl<'c> MulAdd<Wrapping<u8>, &'c Wrapping<u8>> for Wrapping<u8>

type Output = Wrapping<u8>

fn mul_add(self, mul: Wrapping<u8>, add: &'c Wrapping<u8>) -> Self::Output

impl<'b> MulAdd<&'b Wrapping<u8>, Wrapping<u8>> for Wrapping<u8>

type Output = Wrapping<u8>

fn mul_add(self, mul: &'b Wrapping<u8>, add: Wrapping<u8>) -> Self::Output

impl<'b, 'c> MulAdd<&'b Wrapping<u8>, &'c Wrapping<u8>> for Wrapping<u8>

type Output = Wrapping<u8>

fn mul_add(self, mul: &'b Wrapping<u8>, add: &'c Wrapping<u8>) -> Self::Output

impl<'a> MulAdd<Wrapping<u8>, Wrapping<u8>> for &'a Wrapping<u8>

type Output = Wrapping<u8>

fn mul_add(self, mul: Wrapping<u8>, add: Wrapping<u8>) -> Self::Output

impl<'a, 'c> MulAdd<Wrapping<u8>, &'c Wrapping<u8>> for &'a Wrapping<u8>

type Output = Wrapping<u8>

fn mul_add(self, mul: Wrapping<u8>, add: &'c Wrapping<u8>) -> Self::Output

impl<'a, 'b> MulAdd<&'b Wrapping<u8>, Wrapping<u8>> for &'a Wrapping<u8>

type Output = Wrapping<u8>

fn mul_add(self, mul: &'b Wrapping<u8>, add: Wrapping<u8>) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b Wrapping<u8>, &'c Wrapping<u8>> for &'a Wrapping<u8>

type Output = Wrapping<u8>

fn mul_add(self, mul: &'b Wrapping<u8>, add: &'c Wrapping<u8>) -> Self::Output

impl MulAdd<Wrapping<u16>, Wrapping<u16>> for Wrapping<u16>

type Output = Wrapping<u16>

fn mul_add(self, mul: Wrapping<u16>, add: Wrapping<u16>) -> Self::Output

impl<'c> MulAdd<Wrapping<u16>, &'c Wrapping<u16>> for Wrapping<u16>

type Output = Wrapping<u16>

fn mul_add(self, mul: Wrapping<u16>, add: &'c Wrapping<u16>) -> Self::Output

impl<'b> MulAdd<&'b Wrapping<u16>, Wrapping<u16>> for Wrapping<u16>

type Output = Wrapping<u16>

fn mul_add(self, mul: &'b Wrapping<u16>, add: Wrapping<u16>) -> Self::Output

impl<'b, 'c> MulAdd<&'b Wrapping<u16>, &'c Wrapping<u16>> for Wrapping<u16>

type Output = Wrapping<u16>

fn mul_add(self, mul: &'b Wrapping<u16>, add: &'c Wrapping<u16>) -> Self::Output

impl<'a> MulAdd<Wrapping<u16>, Wrapping<u16>> for &'a Wrapping<u16>

type Output = Wrapping<u16>

fn mul_add(self, mul: Wrapping<u16>, add: Wrapping<u16>) -> Self::Output

impl<'a, 'c> MulAdd<Wrapping<u16>, &'c Wrapping<u16>> for &'a Wrapping<u16>

type Output = Wrapping<u16>

fn mul_add(self, mul: Wrapping<u16>, add: &'c Wrapping<u16>) -> Self::Output

impl<'a, 'b> MulAdd<&'b Wrapping<u16>, Wrapping<u16>> for &'a Wrapping<u16>

type Output = Wrapping<u16>

fn mul_add(self, mul: &'b Wrapping<u16>, add: Wrapping<u16>) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b Wrapping<u16>, &'c Wrapping<u16>> for &'a Wrapping<u16>

type Output = Wrapping<u16>

fn mul_add(self, mul: &'b Wrapping<u16>, add: &'c Wrapping<u16>) -> Self::Output

impl MulAdd<Wrapping<u32>, Wrapping<u32>> for Wrapping<u32>

type Output = Wrapping<u32>

fn mul_add(self, mul: Wrapping<u32>, add: Wrapping<u32>) -> Self::Output

impl<'c> MulAdd<Wrapping<u32>, &'c Wrapping<u32>> for Wrapping<u32>

type Output = Wrapping<u32>

fn mul_add(self, mul: Wrapping<u32>, add: &'c Wrapping<u32>) -> Self::Output

impl<'b> MulAdd<&'b Wrapping<u32>, Wrapping<u32>> for Wrapping<u32>

type Output = Wrapping<u32>

fn mul_add(self, mul: &'b Wrapping<u32>, add: Wrapping<u32>) -> Self::Output

impl<'b, 'c> MulAdd<&'b Wrapping<u32>, &'c Wrapping<u32>> for Wrapping<u32>

type Output = Wrapping<u32>

fn mul_add(self, mul: &'b Wrapping<u32>, add: &'c Wrapping<u32>) -> Self::Output

impl<'a> MulAdd<Wrapping<u32>, Wrapping<u32>> for &'a Wrapping<u32>

type Output = Wrapping<u32>

fn mul_add(self, mul: Wrapping<u32>, add: Wrapping<u32>) -> Self::Output

impl<'a, 'c> MulAdd<Wrapping<u32>, &'c Wrapping<u32>> for &'a Wrapping<u32>

type Output = Wrapping<u32>

fn mul_add(self, mul: Wrapping<u32>, add: &'c Wrapping<u32>) -> Self::Output

impl<'a, 'b> MulAdd<&'b Wrapping<u32>, Wrapping<u32>> for &'a Wrapping<u32>

type Output = Wrapping<u32>

fn mul_add(self, mul: &'b Wrapping<u32>, add: Wrapping<u32>) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b Wrapping<u32>, &'c Wrapping<u32>> for &'a Wrapping<u32>

type Output = Wrapping<u32>

fn mul_add(self, mul: &'b Wrapping<u32>, add: &'c Wrapping<u32>) -> Self::Output

impl MulAdd<Wrapping<u64>, Wrapping<u64>> for Wrapping<u64>

type Output = Wrapping<u64>

fn mul_add(self, mul: Wrapping<u64>, add: Wrapping<u64>) -> Self::Output

impl<'c> MulAdd<Wrapping<u64>, &'c Wrapping<u64>> for Wrapping<u64>

type Output = Wrapping<u64>

fn mul_add(self, mul: Wrapping<u64>, add: &'c Wrapping<u64>) -> Self::Output

impl<'b> MulAdd<&'b Wrapping<u64>, Wrapping<u64>> for Wrapping<u64>

type Output = Wrapping<u64>

fn mul_add(self, mul: &'b Wrapping<u64>, add: Wrapping<u64>) -> Self::Output

impl<'b, 'c> MulAdd<&'b Wrapping<u64>, &'c Wrapping<u64>> for Wrapping<u64>

type Output = Wrapping<u64>

fn mul_add(self, mul: &'b Wrapping<u64>, add: &'c Wrapping<u64>) -> Self::Output

impl<'a> MulAdd<Wrapping<u64>, Wrapping<u64>> for &'a Wrapping<u64>

type Output = Wrapping<u64>

fn mul_add(self, mul: Wrapping<u64>, add: Wrapping<u64>) -> Self::Output

impl<'a, 'c> MulAdd<Wrapping<u64>, &'c Wrapping<u64>> for &'a Wrapping<u64>

type Output = Wrapping<u64>

fn mul_add(self, mul: Wrapping<u64>, add: &'c Wrapping<u64>) -> Self::Output

impl<'a, 'b> MulAdd<&'b Wrapping<u64>, Wrapping<u64>> for &'a Wrapping<u64>

type Output = Wrapping<u64>

fn mul_add(self, mul: &'b Wrapping<u64>, add: Wrapping<u64>) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b Wrapping<u64>, &'c Wrapping<u64>> for &'a Wrapping<u64>

type Output = Wrapping<u64>

fn mul_add(self, mul: &'b Wrapping<u64>, add: &'c Wrapping<u64>) -> Self::Output

impl MulAdd<Wrapping<usize>, Wrapping<usize>> for Wrapping<usize>

type Output = Wrapping<usize>

fn mul_add(self, mul: Wrapping<usize>, add: Wrapping<usize>) -> Self::Output

impl<'c> MulAdd<Wrapping<usize>, &'c Wrapping<usize>> for Wrapping<usize>

type Output = Wrapping<usize>

fn mul_add(self, mul: Wrapping<usize>, add: &'c Wrapping<usize>) -> Self::Output

impl<'b> MulAdd<&'b Wrapping<usize>, Wrapping<usize>> for Wrapping<usize>

type Output = Wrapping<usize>

fn mul_add(self, mul: &'b Wrapping<usize>, add: Wrapping<usize>) -> Self::Output

impl<'b, 'c> MulAdd<&'b Wrapping<usize>, &'c Wrapping<usize>> for Wrapping<usize>

type Output = Wrapping<usize>

fn mul_add(
    self,
    mul: &'b Wrapping<usize>,
    add: &'c Wrapping<usize>
) -> Self::Output

impl<'a> MulAdd<Wrapping<usize>, Wrapping<usize>> for &'a Wrapping<usize>

type Output = Wrapping<usize>

fn mul_add(self, mul: Wrapping<usize>, add: Wrapping<usize>) -> Self::Output

impl<'a, 'c> MulAdd<Wrapping<usize>, &'c Wrapping<usize>> for &'a Wrapping<usize>

type Output = Wrapping<usize>

fn mul_add(self, mul: Wrapping<usize>, add: &'c Wrapping<usize>) -> Self::Output

impl<'a, 'b> MulAdd<&'b Wrapping<usize>, Wrapping<usize>> for &'a Wrapping<usize>

type Output = Wrapping<usize>

fn mul_add(self, mul: &'b Wrapping<usize>, add: Wrapping<usize>) -> Self::Output

impl<'a, 'b, 'c> MulAdd<&'b Wrapping<usize>, &'c Wrapping<usize>> for &'a Wrapping<usize>

type Output = Wrapping<usize>

fn mul_add(
    self,
    mul: &'b Wrapping<usize>,
    add: &'c Wrapping<usize>
) -> Self::Output

Loading content...

Implementors

impl<'a, 'b, 'c, T> MulAdd<&'a Extent2<T>, &'b Extent2<T>> for &'c vek::vec::repr_c::extent2::Extent2<T> where
    &'c T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Extent2<T>

fn mul_add(self, a: &'a Extent2<T>, b: &'b Extent2<T>) -> Self::Output

impl<'a, 'b, 'c, T> MulAdd<&'a Extent3<T>, &'b Extent3<T>> for &'c vek::vec::repr_c::extent3::Extent3<T> where
    &'c T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Extent3<T>

fn mul_add(self, a: &'a Extent3<T>, b: &'b Extent3<T>) -> Self::Output

impl<'a, 'b, 'c, T> MulAdd<&'a Rgb<T>, &'b Rgb<T>> for &'c vek::vec::repr_c::rgb::Rgb<T> where
    &'c T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Rgb<T>

fn mul_add(self, a: &'a Rgb<T>, b: &'b Rgb<T>) -> Self::Output

impl<'a, 'b, 'c, T> MulAdd<&'a Rgba<T>, &'b Rgba<T>> for &'c vek::vec::repr_c::rgba::Rgba<T> where
    &'c T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Rgba<T>

fn mul_add(self, a: &'a Rgba<T>, b: &'b Rgba<T>) -> Self::Output

impl<'a, 'b, 'c, T> MulAdd<&'a Vec2<T>, &'b Vec2<T>> for &'c vek::vec::repr_c::vec2::Vec2<T> where
    &'c T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Vec2<T>

fn mul_add(self, a: &'a Vec2<T>, b: &'b Vec2<T>) -> Self::Output

impl<'a, 'b, 'c, T> MulAdd<&'a Vec3<T>, &'b Vec3<T>> for &'c vek::vec::repr_c::vec3::Vec3<T> where
    &'c T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Vec3<T>

fn mul_add(self, a: &'a Vec3<T>, b: &'b Vec3<T>) -> Self::Output

impl<'a, 'b, 'c, T> MulAdd<&'a Vec4<T>, &'b Vec4<T>> for &'c vek::vec::repr_c::vec4::Vec4<T> where
    &'c T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Vec4<T>

fn mul_add(self, a: &'a Vec4<T>, b: &'b Vec4<T>) -> Self::Output

impl<'a, 'b, 'c, T> MulAdd<&'a Extent2<T>, &'b Extent2<T>> for &'c vek::vec::repr_simd::extent2::Extent2<T> where
    &'c T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Extent2<T>

fn mul_add(self, a: &'a Extent2<T>, b: &'b Extent2<T>) -> Self::Output

impl<'a, 'b, 'c, T> MulAdd<&'a Extent3<T>, &'b Extent3<T>> for &'c vek::vec::repr_simd::extent3::Extent3<T> where
    &'c T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Extent3<T>

fn mul_add(self, a: &'a Extent3<T>, b: &'b Extent3<T>) -> Self::Output

impl<'a, 'b, 'c, T> MulAdd<&'a Rgb<T>, &'b Rgb<T>> for &'c vek::vec::repr_simd::rgb::Rgb<T> where
    &'c T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Rgb<T>

fn mul_add(self, a: &'a Rgb<T>, b: &'b Rgb<T>) -> Self::Output

impl<'a, 'b, 'c, T> MulAdd<&'a Rgba<T>, &'b Rgba<T>> for &'c vek::vec::repr_simd::rgba::Rgba<T> where
    &'c T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Rgba<T>

fn mul_add(self, a: &'a Rgba<T>, b: &'b Rgba<T>) -> Self::Output

impl<'a, 'b, 'c, T> MulAdd<&'a Vec2<T>, &'b Vec2<T>> for &'c vek::vec::repr_simd::vec2::Vec2<T> where
    &'c T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Vec2<T>

fn mul_add(self, a: &'a Vec2<T>, b: &'b Vec2<T>) -> Self::Output

impl<'a, 'b, 'c, T> MulAdd<&'a Vec3<T>, &'b Vec3<T>> for &'c vek::vec::repr_simd::vec3::Vec3<T> where
    &'c T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Vec3<T>

fn mul_add(self, a: &'a Vec3<T>, b: &'b Vec3<T>) -> Self::Output

impl<'a, 'b, 'c, T> MulAdd<&'a Vec4<T>, &'b Vec4<T>> for &'c vek::vec::repr_simd::vec4::Vec4<T> where
    &'c T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Vec4<T>

fn mul_add(self, a: &'a Vec4<T>, b: &'b Vec4<T>) -> Self::Output

impl<'a, 'b, T> MulAdd<&'a Extent2<T>, &'b Extent2<T>> for vek::vec::repr_c::extent2::Extent2<T> where
    T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Extent2<T>

fn mul_add(self, a: &'a Extent2<T>, b: &'b Extent2<T>) -> Self::Output

impl<'a, 'b, T> MulAdd<&'a Extent3<T>, &'b Extent3<T>> for vek::vec::repr_c::extent3::Extent3<T> where
    T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Extent3<T>

fn mul_add(self, a: &'a Extent3<T>, b: &'b Extent3<T>) -> Self::Output

impl<'a, 'b, T> MulAdd<&'a Rgb<T>, &'b Rgb<T>> for vek::vec::repr_c::rgb::Rgb<T> where
    T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Rgb<T>

fn mul_add(self, a: &'a Rgb<T>, b: &'b Rgb<T>) -> Self::Output

impl<'a, 'b, T> MulAdd<&'a Rgba<T>, &'b Rgba<T>> for vek::vec::repr_c::rgba::Rgba<T> where
    T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Rgba<T>

fn mul_add(self, a: &'a Rgba<T>, b: &'b Rgba<T>) -> Self::Output

impl<'a, 'b, T> MulAdd<&'a Vec2<T>, &'b Vec2<T>> for vek::vec::repr_c::vec2::Vec2<T> where
    T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Vec2<T>

fn mul_add(self, a: &'a Vec2<T>, b: &'b Vec2<T>) -> Self::Output

impl<'a, 'b, T> MulAdd<&'a Vec3<T>, &'b Vec3<T>> for vek::vec::repr_c::vec3::Vec3<T> where
    T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Vec3<T>

fn mul_add(self, a: &'a Vec3<T>, b: &'b Vec3<T>) -> Self::Output

impl<'a, 'b, T> MulAdd<&'a Vec4<T>, &'b Vec4<T>> for vek::vec::repr_c::vec4::Vec4<T> where
    T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Vec4<T>

fn mul_add(self, a: &'a Vec4<T>, b: &'b Vec4<T>) -> Self::Output

impl<'a, 'b, T> MulAdd<&'a Extent2<T>, &'b Extent2<T>> for vek::vec::repr_simd::extent2::Extent2<T> where
    T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Extent2<T>

fn mul_add(self, a: &'a Extent2<T>, b: &'b Extent2<T>) -> Self::Output

impl<'a, 'b, T> MulAdd<&'a Extent3<T>, &'b Extent3<T>> for vek::vec::repr_simd::extent3::Extent3<T> where
    T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Extent3<T>

fn mul_add(self, a: &'a Extent3<T>, b: &'b Extent3<T>) -> Self::Output

impl<'a, 'b, T> MulAdd<&'a Rgb<T>, &'b Rgb<T>> for vek::vec::repr_simd::rgb::Rgb<T> where
    T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Rgb<T>

fn mul_add(self, a: &'a Rgb<T>, b: &'b Rgb<T>) -> Self::Output

impl<'a, 'b, T> MulAdd<&'a Rgba<T>, &'b Rgba<T>> for vek::vec::repr_simd::rgba::Rgba<T> where
    T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Rgba<T>

fn mul_add(self, a: &'a Rgba<T>, b: &'b Rgba<T>) -> Self::Output

impl<'a, 'b, T> MulAdd<&'a Vec2<T>, &'b Vec2<T>> for vek::vec::repr_simd::vec2::Vec2<T> where
    T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Vec2<T>

fn mul_add(self, a: &'a Vec2<T>, b: &'b Vec2<T>) -> Self::Output

impl<'a, 'b, T> MulAdd<&'a Vec3<T>, &'b Vec3<T>> for vek::vec::repr_simd::vec3::Vec3<T> where
    T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Vec3<T>

fn mul_add(self, a: &'a Vec3<T>, b: &'b Vec3<T>) -> Self::Output

impl<'a, 'b, T> MulAdd<&'a Vec4<T>, &'b Vec4<T>> for vek::vec::repr_simd::vec4::Vec4<T> where
    T: MulAdd<&'a T, &'b T, Output = T>, 

type Output = Vec4<T>

fn mul_add(self, a: &'a Vec4<T>, b: &'b Vec4<T>) -> Self::Output

impl<'a, 'c, T> MulAdd<&'a Extent2<T>, Extent2<T>> for &'c vek::vec::repr_c::extent2::Extent2<T> where
    &'c T: MulAdd<&'a T, T, Output = T>, 

type Output = Extent2<T>

fn mul_add(self, a: &'a Extent2<T>, b: Extent2<T>) -> Self::Output

impl<'a, 'c, T> MulAdd<&'a Extent3<T>, Extent3<T>> for &'c vek::vec::repr_c::extent3::Extent3<T> where
    &'c T: MulAdd<&'a T, T, Output = T>, 

type Output = Extent3<T>

fn mul_add(self, a: &'a Extent3<T>, b: Extent3<T>) -> Self::Output

impl<'a, 'c, T> MulAdd<&'a Rgb<T>, Rgb<T>> for &'c vek::vec::repr_c::rgb::Rgb<T> where
    &'c T: MulAdd<&'a T, T, Output = T>, 

type Output = Rgb<T>

fn mul_add(self, a: &'a Rgb<T>, b: Rgb<T>) -> Self::Output

impl<'a, 'c, T> MulAdd<&'a Rgba<T>, Rgba<T>> for &'c vek::vec::repr_c::rgba::Rgba<T> where
    &'c T: MulAdd<&'a T, T, Output = T>, 

type Output = Rgba<T>

fn mul_add(self, a: &'a Rgba<T>, b: Rgba<T>) -> Self::Output

impl<'a, 'c, T> MulAdd<&'a Vec2<T>, Vec2<T>> for &'c vek::vec::repr_c::vec2::Vec2<T> where
    &'c T: MulAdd<&'a T, T, Output = T>, 

type Output = Vec2<T>

fn mul_add(self, a: &'a Vec2<T>, b: Vec2<T>) -> Self::Output

impl<'a, 'c, T> MulAdd<&'a Vec3<T>, Vec3<T>> for &'c vek::vec::repr_c::vec3::Vec3<T> where
    &'c T: MulAdd<&'a T, T, Output = T>, 

type Output = Vec3<T>

fn mul_add(self, a: &'a Vec3<T>, b: Vec3<T>) -> Self::Output

impl<'a, 'c, T> MulAdd<&'a Vec4<T>, Vec4<T>> for &'c vek::vec::repr_c::vec4::Vec4<T> where
    &'c T: MulAdd<&'a T, T, Output = T>, 

type Output = Vec4<T>

fn mul_add(self, a: &'a Vec4<T>, b: Vec4<T>) -> Self::Output

impl<'a, 'c, T> MulAdd<&'a Extent2<T>, Extent2<T>> for &'c vek::vec::repr_simd::extent2::Extent2<T> where
    &'c T: MulAdd<&'a T, T, Output = T>, 

type Output = Extent2<T>

fn mul_add(self, a: &'a Extent2<T>, b: Extent2<T>) -> Self::Output

impl<'a, 'c, T> MulAdd<&'a Extent3<T>, Extent3<T>> for &'c vek::vec::repr_simd::extent3::Extent3<T> where
    &'c T: MulAdd<&'a T, T, Output = T>, 

type Output = Extent3<T>

fn mul_add(self, a: &'a Extent3<T>, b: Extent3<T>) -> Self::Output

impl<'a, 'c, T> MulAdd<&'a Rgb<T>, Rgb<T>> for &'c vek::vec::repr_simd::rgb::Rgb<T> where
    &'c T: MulAdd<&'a T, T, Output = T>, 

type Output = Rgb<T>

fn mul_add(self, a: &'a Rgb<T>, b: Rgb<T>) -> Self::Output

impl<'a, 'c, T> MulAdd<&'a Rgba<T>, Rgba<T>> for &'c vek::vec::repr_simd::rgba::Rgba<T> where
    &'c T: MulAdd<&'a T, T, Output = T>, 

type Output = Rgba<T>

fn mul_add(self, a: &'a Rgba<T>, b: Rgba<T>) -> Self::Output

impl<'a, 'c, T> MulAdd<&'a Vec2<T>, Vec2<T>> for &'c vek::vec::repr_simd::vec2::Vec2<T> where
    &'c T: MulAdd<&'a T, T, Output = T>, 

type Output = Vec2<T>

fn mul_add(self, a: &'a Vec2<T>, b: Vec2<T>) -> Self::Output

impl<'a, 'c, T> MulAdd<&'a Vec3<T>, Vec3<T>> for &'c vek::vec::repr_simd::vec3::Vec3<T> where
    &'c T: MulAdd<&'a T, T, Output = T>, 

type Output = Vec3<T>

fn mul_add(self, a: &'a Vec3<T>, b: Vec3<T>) -> Self::Output

impl<'a, 'c, T> MulAdd<&'a Vec4<T>, Vec4<T>> for &'c vek::vec::repr_simd::vec4::Vec4<T> where
    &'c T: MulAdd<&'a T, T, Output = T>, 

type Output = Vec4<T>

fn mul_add(self, a: &'a Vec4<T>, b: Vec4<T>) -> Self::Output

impl<'a, T> MulAdd<&'a Extent2<T>, Extent2<T>> for vek::vec::repr_c::extent2::Extent2<T> where
    T: MulAdd<&'a T, T, Output = T>, 

type Output = Extent2<T>

fn mul_add(self, a: &'a Extent2<T>, b: Extent2<T>) -> Self::Output

impl<'a, T> MulAdd<&'a Extent3<T>, Extent3<T>> for vek::vec::repr_c::extent3::Extent3<T> where
    T: MulAdd<&'a T, T, Output = T>, 

type Output = Extent3<T>

fn mul_add(self, a: &'a Extent3<T>, b: Extent3<T>) -> Self::Output

impl<'a, T> MulAdd<&'a Rgb<T>, Rgb<T>> for vek::vec::repr_c::rgb::Rgb<T> where
    T: MulAdd<&'a T, T, Output = T>, 

type Output = Rgb<T>

fn mul_add(self, a: &'a Rgb<T>, b: Rgb<T>) -> Self::Output

impl<'a, T> MulAdd<&'a Rgba<T>, Rgba<T>> for vek::vec::repr_c::rgba::Rgba<T> where
    T: MulAdd<&'a T, T, Output = T>, 

type Output = Rgba<T>

fn mul_add(self, a: &'a Rgba<T>, b: Rgba<T>) -> Self::Output

impl<'a, T> MulAdd<&'a Vec2<T>, Vec2<T>> for vek::vec::repr_c::vec2::Vec2<T> where
    T: MulAdd<&'a T, T, Output = T>, 

type Output = Vec2<T>

fn mul_add(self, a: &'a Vec2<T>, b: Vec2<T>) -> Self::Output

impl<'a, T> MulAdd<&'a Vec3<T>, Vec3<T>> for vek::vec::repr_c::vec3::Vec3<T> where
    T: MulAdd<&'a T, T, Output = T>, 

type Output = Vec3<T>

fn mul_add(self, a: &'a Vec3<T>, b: Vec3<T>) -> Self::Output

impl<'a, T> MulAdd<&'a Vec4<T>, Vec4<T>> for vek::vec::repr_c::vec4::Vec4<T> where
    T: MulAdd<&'a T, T, Output = T>, 

type Output = Vec4<T>

fn mul_add(self, a: &'a Vec4<T>, b: Vec4<T>) -> Self::Output

impl<'a, T> MulAdd<&'a Extent2<T>, Extent2<T>> for vek::vec::repr_simd::extent2::Extent2<T> where
    T: MulAdd<&'a T, T, Output = T>, 

type Output = Extent2<T>

fn mul_add(self, a: &'a Extent2<T>, b: Extent2<T>) -> Self::Output

impl<'a, T> MulAdd<&'a Extent3<T>, Extent3<T>> for vek::vec::repr_simd::extent3::Extent3<T> where
    T: MulAdd<&'a T, T, Output = T>, 

type Output = Extent3<T>

fn mul_add(self, a: &'a Extent3<T>, b: Extent3<T>) -> Self::Output

impl<'a, T> MulAdd<&'a Rgb<T>, Rgb<T>> for vek::vec::repr_simd::rgb::Rgb<T> where
    T: MulAdd<&'a T, T, Output = T>, 

type Output = Rgb<T>

fn mul_add(self, a: &'a Rgb<T>, b: Rgb<T>) -> Self::Output

impl<'a, T> MulAdd<&'a Rgba<T>, Rgba<T>> for vek::vec::repr_simd::rgba::Rgba<T> where
    T: MulAdd<&'a T, T, Output = T>, 

type Output = Rgba<T>

fn mul_add(self, a: &'a Rgba<T>, b: Rgba<T>) -> Self::Output

impl<'a, T> MulAdd<&'a Vec2<T>, Vec2<T>> for vek::vec::repr_simd::vec2::Vec2<T> where
    T: MulAdd<&'a T, T, Output = T>, 

type Output = Vec2<T>

fn mul_add(self, a: &'a Vec2<T>, b: Vec2<T>) -> Self::Output

impl<'a, T> MulAdd<&'a Vec3<T>, Vec3<T>> for vek::vec::repr_simd::vec3::Vec3<T> where
    T: MulAdd<&'a T, T, Output = T>, 

type Output = Vec3<T>

fn mul_add(self, a: &'a Vec3<T>, b: Vec3<T>) -> Self::Output

impl<'a, T> MulAdd<&'a Vec4<T>, Vec4<T>> for vek::vec::repr_simd::vec4::Vec4<T> where
    T: MulAdd<&'a T, T, Output = T>, 

type Output = Vec4<T>

fn mul_add(self, a: &'a Vec4<T>, b: Vec4<T>) -> Self::Output

impl<'b, 'c, T> MulAdd<Extent2<T>, &'b Extent2<T>> for &'c vek::vec::repr_c::extent2::Extent2<T> where
    &'c T: MulAdd<T, &'b T, Output = T>, 

type Output = Extent2<T>

fn mul_add(self, a: Extent2<T>, b: &'b Extent2<T>) -> Self::Output

impl<'b, 'c, T> MulAdd<Extent3<T>, &'b Extent3<T>> for &'c vek::vec::repr_c::extent3::Extent3<T> where
    &'c T: MulAdd<T, &'b T, Output = T>, 

type Output = Extent3<T>

fn mul_add(self, a: Extent3<T>, b: &'b Extent3<T>) -> Self::Output

impl<'b, 'c, T> MulAdd<Rgb<T>, &'b Rgb<T>> for &'c vek::vec::repr_c::rgb::Rgb<T> where
    &'c T: MulAdd<T, &'b T, Output = T>, 

type Output = Rgb<T>

fn mul_add(self, a: Rgb<T>, b: &'b Rgb<T>) -> Self::Output

impl<'b, 'c, T> MulAdd<Rgba<T>, &'b Rgba<T>> for &'c vek::vec::repr_c::rgba::Rgba<T> where
    &'c T: MulAdd<T, &'b T, Output = T>, 

type Output = Rgba<T>

fn mul_add(self, a: Rgba<T>, b: &'b Rgba<T>) -> Self::Output

impl<'b, 'c, T> MulAdd<Vec2<T>, &'b Vec2<T>> for &'c vek::vec::repr_c::vec2::Vec2<T> where
    &'c T: MulAdd<T, &'b T, Output = T>, 

type Output = Vec2<T>

fn mul_add(self, a: Vec2<T>, b: &'b Vec2<T>) -> Self::Output

impl<'b, 'c, T> MulAdd<Vec3<T>, &'b Vec3<T>> for &'c vek::vec::repr_c::vec3::Vec3<T> where
    &'c T: MulAdd<T, &'b T, Output = T>, 

type Output = Vec3<T>

fn mul_add(self, a: Vec3<T>, b: &'b Vec3<T>) -> Self::Output

impl<'b, 'c, T> MulAdd<Vec4<T>, &'b Vec4<T>> for &'c vek::vec::repr_c::vec4::Vec4<T> where
    &'c T: MulAdd<T, &'b T, Output = T>, 

type Output = Vec4<T>

fn mul_add(self, a: Vec4<T>, b: &'b Vec4<T>) -> Self::Output

impl<'b, 'c, T> MulAdd<Extent2<T>, &'b Extent2<T>> for &'c vek::vec::repr_simd::extent2::Extent2<T> where
    &'c T: MulAdd<T, &'b T, Output = T>, 

type Output = Extent2<T>

fn mul_add(self, a: Extent2<T>, b: &'b Extent2<T>) -> Self::Output

impl<'b, 'c, T> MulAdd<Extent3<T>, &'b Extent3<T>> for &'c vek::vec::repr_simd::extent3::Extent3<T> where
    &'c T: MulAdd<T, &'b T, Output = T>, 

type Output = Extent3<T>

fn mul_add(self, a: Extent3<T>, b: &'b Extent3<T>) -> Self::Output

impl<'b, 'c, T> MulAdd<Rgb<T>, &'b Rgb<T>> for &'c vek::vec::repr_simd::rgb::Rgb<T> where
    &'c T: MulAdd<T, &'b T, Output = T>, 

type Output = Rgb<T>

fn mul_add(self, a: Rgb<T>, b: &'b Rgb<T>) -> Self::Output

impl<'b, 'c, T> MulAdd<Rgba<T>, &'b Rgba<T>> for &'c vek::vec::repr_simd::rgba::Rgba<T> where
    &'c T: MulAdd<T, &'b T, Output = T>, 

type Output = Rgba<T>

fn mul_add(self, a: Rgba<T>, b: &'b Rgba<T>) -> Self::Output

impl<'b, 'c, T> MulAdd<Vec2<T>, &'b Vec2<T>> for &'c vek::vec::repr_simd::vec2::Vec2<T> where
    &'c T: MulAdd<T, &'b T, Output = T>, 

type Output = Vec2<T>

fn mul_add(self, a: Vec2<T>, b: &'b Vec2<T>) -> Self::Output

impl<'b, 'c, T> MulAdd<Vec3<T>, &'b Vec3<T>> for &'c vek::vec::repr_simd::vec3::Vec3<T> where
    &'c T: MulAdd<T, &'b T, Output = T>, 

type Output = Vec3<T>

fn mul_add(self, a: Vec3<T>, b: &'b Vec3<T>) -> Self::Output

impl<'b, 'c, T> MulAdd<Vec4<T>, &'b Vec4<T>> for &'c vek::vec::repr_simd::vec4::Vec4<T> where
    &'c T: MulAdd<T, &'b T, Output = T>, 

type Output = Vec4<T>

fn mul_add(self, a: Vec4<T>, b: &'b Vec4<T>) -> Self::Output

impl<'b, T> MulAdd<Extent2<T>, &'b Extent2<T>> for vek::vec::repr_c::extent2::Extent2<T> where
    T: MulAdd<T, &'b T, Output = T>, 

type Output = Extent2<T>

fn mul_add(self, a: Extent2<T>, b: &'b Extent2<T>) -> Self::Output

impl<'b, T> MulAdd<Extent3<T>, &'b Extent3<T>> for vek::vec::repr_c::extent3::Extent3<T> where
    T: MulAdd<T, &'b T, Output = T>, 

type Output = Extent3<T>

fn mul_add(self, a: Extent3<T>, b: &'b Extent3<T>) -> Self::Output

impl<'b, T> MulAdd<Rgb<T>, &'b Rgb<T>> for vek::vec::repr_c::rgb::Rgb<T> where
    T: MulAdd<T, &'b T, Output = T>, 

type Output = Rgb<T>

fn mul_add(self, a: Rgb<T>, b: &'b Rgb<T>) -> Self::Output

impl<'b, T> MulAdd<Rgba<T>, &'b Rgba<T>> for vek::vec::repr_c::rgba::Rgba<T> where
    T: MulAdd<T, &'b T, Output = T>, 

type Output = Rgba<T>

fn mul_add(self, a: Rgba<T>, b: &'b Rgba<T>) -> Self::Output

impl<'b, T> MulAdd<Vec2<T>, &'b Vec2<T>> for vek::vec::repr_c::vec2::Vec2<T> where
    T: MulAdd<T, &'b T, Output = T>, 

type Output = Vec2<T>

fn mul_add(self, a: Vec2<T>, b: &'b Vec2<T>) -> Self::Output

impl<'b, T> MulAdd<Vec3<T>, &'b Vec3<T>> for vek::vec::repr_c::vec3::Vec3<T> where
    T: MulAdd<T, &'b T, Output = T>, 

type Output = Vec3<T>

fn mul_add(self, a: Vec3<T>, b: &'b Vec3<T>) -> Self::Output

impl<'b, T> MulAdd<Vec4<T>, &'b Vec4<T>> for vek::vec::repr_c::vec4::Vec4<T> where
    T: MulAdd<T, &'b T, Output = T>, 

type Output = Vec4<T>

fn mul_add(self, a: Vec4<T>, b: &'b Vec4<T>) -> Self::Output

impl<'b, T> MulAdd<Extent2<T>, &'b Extent2<T>> for vek::vec::repr_simd::extent2::Extent2<T> where
    T: MulAdd<T, &'b T, Output = T>, 

type Output = Extent2<T>

fn mul_add(self, a: Extent2<T>, b: &'b Extent2<T>) -> Self::Output

impl<'b, T> MulAdd<Extent3<T>, &'b Extent3<T>> for vek::vec::repr_simd::extent3::Extent3<T> where
    T: MulAdd<T, &'b T, Output = T>, 

type Output = Extent3<T>

fn mul_add(self, a: Extent3<T>, b: &'b Extent3<T>) -> Self::Output

impl<'b, T> MulAdd<Rgb<T>, &'b Rgb<T>> for vek::vec::repr_simd::rgb::Rgb<T> where
    T: MulAdd<T, &'b T, Output = T>, 

type Output = Rgb<T>

fn mul_add(self, a: Rgb<T>, b: &'b Rgb<T>) -> Self::Output

impl<'b, T> MulAdd<Rgba<T>, &'b Rgba<T>> for vek::vec::repr_simd::rgba::Rgba<T> where
    T: MulAdd<T, &'b T, Output = T>, 

type Output = Rgba<T>

fn mul_add(self, a: Rgba<T>, b: &'b Rgba<T>) -> Self::Output

impl<'b, T> MulAdd<Vec2<T>, &'b Vec2<T>> for vek::vec::repr_simd::vec2::Vec2<T> where
    T: MulAdd<T, &'b T, Output = T>, 

type Output = Vec2<T>

fn mul_add(self, a: Vec2<T>, b: &'b Vec2<T>) -> Self::Output

impl<'b, T> MulAdd<Vec3<T>, &'b Vec3<T>> for vek::vec::repr_simd::vec3::Vec3<T> where
    T: MulAdd<T, &'b T, Output = T>, 

type Output = Vec3<T>

fn mul_add(self, a: Vec3<T>, b: &'b Vec3<T>) -> Self::Output

impl<'b, T> MulAdd<Vec4<T>, &'b Vec4<T>> for vek::vec::repr_simd::vec4::Vec4<T> where
    T: MulAdd<T, &'b T, Output = T>, 

type Output = Vec4<T>

fn mul_add(self, a: Vec4<T>, b: &'b Vec4<T>) -> Self::Output

impl<'c, T> MulAdd<Extent2<T>, Extent2<T>> for &'c vek::vec::repr_c::extent2::Extent2<T> where
    &'c T: MulAdd<T, T, Output = T>, 

type Output = Extent2<T>

fn mul_add(self, a: Extent2<T>, b: Extent2<T>) -> Self::Output

impl<'c, T> MulAdd<Extent3<T>, Extent3<T>> for &'c vek::vec::repr_c::extent3::Extent3<T> where
    &'c T: MulAdd<T, T, Output = T>, 

type Output = Extent3<T>

fn mul_add(self, a: Extent3<T>, b: Extent3<T>) -> Self::Output

impl<'c, T> MulAdd<Rgb<T>, Rgb<T>> for &'c vek::vec::repr_c::rgb::Rgb<T> where
    &'c T: MulAdd<T, T, Output = T>, 

type Output = Rgb<T>

fn mul_add(self, a: Rgb<T>, b: Rgb<T>) -> Self::Output

impl<'c, T> MulAdd<Rgba<T>, Rgba<T>> for &'c vek::vec::repr_c::rgba::Rgba<T> where
    &'c T: MulAdd<T, T, Output = T>, 

type Output = Rgba<T>

fn mul_add(self, a: Rgba<T>, b: Rgba<T>) -> Self::Output

impl<'c, T> MulAdd<Vec2<T>, Vec2<T>> for &'c vek::vec::repr_c::vec2::Vec2<T> where
    &'c T: MulAdd<T, T, Output = T>, 

type Output = Vec2<T>

fn mul_add(self, a: Vec2<T>, b: Vec2<T>) -> Self::Output

impl<'c, T> MulAdd<Vec3<T>, Vec3<T>> for &'c vek::vec::repr_c::vec3::Vec3<T> where
    &'c T: MulAdd<T, T, Output = T>, 

type Output = Vec3<T>

fn mul_add(self, a: Vec3<T>, b: Vec3<T>) -> Self::Output

impl<'c, T> MulAdd<Vec4<T>, Vec4<T>> for &'c vek::vec::repr_c::vec4::Vec4<T> where
    &'c T: MulAdd<T, T, Output = T>, 

type Output = Vec4<T>

fn mul_add(self, a: Vec4<T>, b: Vec4<T>) -> Self::Output

impl<'c, T> MulAdd<Extent2<T>, Extent2<T>> for &'c vek::vec::repr_simd::extent2::Extent2<T> where
    &'c T: MulAdd<T, T, Output = T>, 

type Output = Extent2<T>

fn mul_add(self, a: Extent2<T>, b: Extent2<T>) -> Self::Output

impl<'c, T> MulAdd<Extent3<T>, Extent3<T>> for &'c vek::vec::repr_simd::extent3::Extent3<T> where
    &'c T: MulAdd<T, T, Output = T>, 

type Output = Extent3<T>

fn mul_add(self, a: Extent3<T>, b: Extent3<T>) -> Self::Output

impl<'c, T> MulAdd<Rgb<T>, Rgb<T>> for &'c vek::vec::repr_simd::rgb::Rgb<T> where
    &'c T: MulAdd<T, T, Output = T>, 

type Output = Rgb<T>

fn mul_add(self, a: Rgb<T>, b: Rgb<T>) -> Self::Output

impl<'c, T> MulAdd<Rgba<T>, Rgba<T>> for &'c vek::vec::repr_simd::rgba::Rgba<T> where
    &'c T: MulAdd<T, T, Output = T>, 

type Output = Rgba<T>

fn mul_add(self, a: Rgba<T>, b: Rgba<T>) -> Self::Output

impl<'c, T> MulAdd<Vec2<T>, Vec2<T>> for &'c vek::vec::repr_simd::vec2::Vec2<T> where
    &'c T: MulAdd<T, T, Output = T>, 

type Output = Vec2<T>

fn mul_add(self, a: Vec2<T>, b: Vec2<T>) -> Self::Output

impl<'c, T> MulAdd<Vec3<T>, Vec3<T>> for &'c vek::vec::repr_simd::vec3::Vec3<T> where
    &'c T: MulAdd<T, T, Output = T>, 

type Output = Vec3<T>

fn mul_add(self, a: Vec3<T>, b: Vec3<T>) -> Self::Output

impl<'c, T> MulAdd<Vec4<T>, Vec4<T>> for &'c vek::vec::repr_simd::vec4::Vec4<T> where
    &'c T: MulAdd<T, T, Output = T>, 

type Output = Vec4<T>

fn mul_add(self, a: Vec4<T>, b: Vec4<T>) -> Self::Output

impl<T> MulAdd<Extent2<T>, Extent2<T>> for vek::vec::repr_c::extent2::Extent2<T> where
    T: MulAdd<T, T, Output = T>, 

type Output = Extent2<T>

fn mul_add(self, a: Extent2<T>, b: Extent2<T>) -> Self::Output

impl<T> MulAdd<Extent3<T>, Extent3<T>> for vek::vec::repr_c::extent3::Extent3<T> where
    T: MulAdd<T, T, Output = T>, 

type Output = Extent3<T>

fn mul_add(self, a: Extent3<T>, b: Extent3<T>) -> Self::Output

impl<T> MulAdd<Rgb<T>, Rgb<T>> for vek::vec::repr_c::rgb::Rgb<T> where
    T: MulAdd<T, T, Output = T>, 

type Output = Rgb<T>

fn mul_add(self, a: Rgb<T>, b: Rgb<T>) -> Self::Output

impl<T> MulAdd<Rgba<T>, Rgba<T>> for vek::vec::repr_c::rgba::Rgba<T> where
    T: MulAdd<T, T, Output = T>, 

type Output = Rgba<T>

fn mul_add(self, a: Rgba<T>, b: Rgba<T>) -> Self::Output

impl<T> MulAdd<Vec2<T>, Vec2<T>> for vek::vec::repr_c::vec2::Vec2<T> where
    T: MulAdd<T, T, Output = T>, 

type Output = Vec2<T>

fn mul_add(self, a: Vec2<T>, b: Vec2<T>) -> Self::Output

impl<T> MulAdd<Vec3<T>, Vec3<T>> for vek::vec::repr_c::vec3::Vec3<T> where
    T: MulAdd<T, T, Output = T>, 

type Output = Vec3<T>

fn mul_add(self, a: Vec3<T>, b: Vec3<T>) -> Self::Output

impl<T> MulAdd<Vec4<T>, Vec4<T>> for vek::vec::repr_c::vec4::Vec4<T> where
    T: MulAdd<T, T, Output = T>, 

type Output = Vec4<T>

fn mul_add(self, a: Vec4<T>, b: Vec4<T>) -> Self::Output

impl<T> MulAdd<Extent2<T>, Extent2<T>> for vek::vec::repr_simd::extent2::Extent2<T> where
    T: MulAdd<T, T, Output = T>, 

type Output = Extent2<T>

fn mul_add(self, a: Extent2<T>, b: Extent2<T>) -> Self::Output

impl<T> MulAdd<Extent3<T>, Extent3<T>> for vek::vec::repr_simd::extent3::Extent3<T> where
    T: MulAdd<T, T, Output = T>, 

type Output = Extent3<T>

fn mul_add(self, a: Extent3<T>, b: Extent3<T>) -> Self::Output

impl<T> MulAdd<Rgb<T>, Rgb<T>> for vek::vec::repr_simd::rgb::Rgb<T> where
    T: MulAdd<T, T, Output = T>, 

type Output = Rgb<T>

fn mul_add(self, a: Rgb<T>, b: Rgb<T>) -> Self::Output

impl<T> MulAdd<Rgba<T>, Rgba<T>> for vek::vec::repr_simd::rgba::Rgba<T> where
    T: MulAdd<T, T, Output = T>, 

type Output = Rgba<T>

fn mul_add(self, a: Rgba<T>, b: Rgba<T>) -> Self::Output

impl<T> MulAdd<Vec2<T>, Vec2<T>> for vek::vec::repr_simd::vec2::Vec2<T> where
    T: MulAdd<T, T, Output = T>, 

type Output = Vec2<T>

fn mul_add(self, a: Vec2<T>, b: Vec2<T>) -> Self::Output

impl<T> MulAdd<Vec3<T>, Vec3<T>> for vek::vec::repr_simd::vec3::Vec3<T> where
    T: MulAdd<T, T, Output = T>, 

type Output = Vec3<T>

fn mul_add(self, a: Vec3<T>, b: Vec3<T>) -> Self::Output

impl<T> MulAdd<Vec4<T>, Vec4<T>> for vek::vec::repr_simd::vec4::Vec4<T> where
    T: MulAdd<T, T, Output = T>, 

type Output = Vec4<T>

fn mul_add(self, a: Vec4<T>, b: Vec4<T>) -> Self::Output

Loading content...