Trait caffe2_imports::Mul

pub trait Mul<Rhs = Self> {
    type Output;

    // Required method
    fn mul(self, rhs: Rhs) -> Self::Output;
}

The multiplication operator *.

Note that Rhs is Self by default, but this is not mandatory.

Examples

Multipliable rational numbers

use std::ops::Mul;

// By the fundamental theorem of arithmetic, rational numbers in lowest
// terms are unique. So, by keeping `Rational`s in reduced form, we can
// derive `Eq` and `PartialEq`.
#[derive(Debug, Eq, PartialEq)]
struct Rational {
    numerator: usize,
    denominator: usize,
}

impl Rational {
    fn new(numerator: usize, denominator: usize) -> Self {
        if denominator == 0 {
            panic!("Zero is an invalid denominator!");
        }

        // Reduce to lowest terms by dividing by the greatest common
        // divisor.
        let gcd = gcd(numerator, denominator);
        Self {
            numerator: numerator / gcd,
            denominator: denominator / gcd,
        }
    }
}

impl Mul for Rational {
    // The multiplication of rational numbers is a closed operation.
    type Output = Self;

    fn mul(self, rhs: Self) -> Self {
        let numerator = self.numerator * rhs.numerator;
        let denominator = self.denominator * rhs.denominator;
        Self::new(numerator, denominator)
    }
}

// Euclid's two-thousand-year-old algorithm for finding the greatest common
// divisor.
fn gcd(x: usize, y: usize) -> usize {
    let mut x = x;
    let mut y = y;
    while y != 0 {
        let t = y;
        y = x % y;
        x = t;
    }
    x
}

assert_eq!(Rational::new(1, 2), Rational::new(2, 4));
assert_eq!(Rational::new(2, 3) * Rational::new(3, 4),
           Rational::new(1, 2));

Multiplying vectors by scalars as in linear algebra

use std::ops::Mul;

struct Scalar { value: usize }

#[derive(Debug, PartialEq)]
struct Vector { value: Vec<usize> }

impl Mul<Scalar> for Vector {
    type Output = Self;

    fn mul(self, rhs: Scalar) -> Self::Output {
        Self { value: self.value.iter().map(|v| v * rhs.value).collect() }
    }
}

let vector = Vector { value: vec![2, 4, 6] };
let scalar = Scalar { value: 3 };
assert_eq!(vector * scalar, Vector { value: vec![6, 12, 18] });

Required Associated Types

type Output

The resulting type after applying the * operator.

Required Methods

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

Performs the * operation.

Example

assert_eq!(12 * 2, 24);

Implementors

impl Mul<&f32> for &f32

type Output = <f32 as Mul<f32>>::Output

impl Mul<&f32> for f32

type Output = <f32 as Mul<f32>>::Output

impl Mul<&f64> for &f64

type Output = <f64 as Mul<f64>>::Output

impl Mul<&f64> for &Mat

type Output = MatExprResult<MatExpr>

impl Mul<&f64> for &MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<&f64> for MatExprResult<&Mat>

type Output = MatExprResult<MatExpr>

impl Mul<&f64> for MatExprResult<&MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<&f64> for MatExprResult<Mat>

type Output = MatExprResult<MatExpr>

impl Mul<&f64> for MatExprResult<MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<&f64> for f64

type Output = <f64 as Mul<f64>>::Output

impl Mul<&f64> for Mat

type Output = MatExprResult<MatExpr>

impl Mul<&f64> for MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<&i8> for &i8

type Output = <i8 as Mul<i8>>::Output

impl Mul<&i8> for i8

type Output = <i8 as Mul<i8>>::Output

impl Mul<&i16> for &i16

type Output = <i16 as Mul<i16>>::Output

impl Mul<&i16> for i16

type Output = <i16 as Mul<i16>>::Output

impl Mul<&i32> for &i32

type Output = <i32 as Mul<i32>>::Output

impl Mul<&i32> for i32

type Output = <i32 as Mul<i32>>::Output

impl Mul<&i64> for &i64

type Output = <i64 as Mul<i64>>::Output

impl Mul<&i64> for i64

type Output = <i64 as Mul<i64>>::Output

impl Mul<&i128> for &i128

type Output = <i128 as Mul<i128>>::Output

impl Mul<&i128> for i128

type Output = <i128 as Mul<i128>>::Output

impl Mul<&isize> for &isize

type Output = <isize as Mul<isize>>::Output

impl Mul<&isize> for isize

type Output = <isize as Mul<isize>>::Output

impl Mul<&u8> for &u8

type Output = <u8 as Mul<u8>>::Output

impl Mul<&u8> for u8

type Output = <u8 as Mul<u8>>::Output

impl Mul<&u16> for &u16

type Output = <u16 as Mul<u16>>::Output

impl Mul<&u16> for u16

type Output = <u16 as Mul<u16>>::Output

impl Mul<&u32> for &u32

type Output = <u32 as Mul<u32>>::Output

impl Mul<&u32> for u32

type Output = <u32 as Mul<u32>>::Output

impl Mul<&u64> for &u64

type Output = <u64 as Mul<u64>>::Output

impl Mul<&u64> for u64

type Output = <u64 as Mul<u64>>::Output

impl Mul<&u128> for &u128

type Output = <u128 as Mul<u128>>::Output

impl Mul<&u128> for u128

type Output = <u128 as Mul<u128>>::Output

impl Mul<&usize> for &usize

type Output = <usize as Mul<usize>>::Output

impl Mul<&usize> for usize

type Output = <usize as Mul<usize>>::Output

impl Mul<&Saturating<i8>> for &Saturating<i8>

type Output = <Saturating<i8> as Mul<Saturating<i8>>>::Output

impl Mul<&Saturating<i8>> for Saturating<i8>

type Output = <Saturating<i8> as Mul<Saturating<i8>>>::Output

impl Mul<&Saturating<i16>> for &Saturating<i16>

type Output = <Saturating<i16> as Mul<Saturating<i16>>>::Output

impl Mul<&Saturating<i16>> for Saturating<i16>

type Output = <Saturating<i16> as Mul<Saturating<i16>>>::Output

impl Mul<&Saturating<i32>> for &Saturating<i32>

type Output = <Saturating<i32> as Mul<Saturating<i32>>>::Output

impl Mul<&Saturating<i32>> for Saturating<i32>

type Output = <Saturating<i32> as Mul<Saturating<i32>>>::Output

impl Mul<&Saturating<i64>> for &Saturating<i64>

type Output = <Saturating<i64> as Mul<Saturating<i64>>>::Output

impl Mul<&Saturating<i64>> for Saturating<i64>

type Output = <Saturating<i64> as Mul<Saturating<i64>>>::Output

impl Mul<&Saturating<i128>> for &Saturating<i128>

type Output = <Saturating<i128> as Mul<Saturating<i128>>>::Output

impl Mul<&Saturating<i128>> for Saturating<i128>

type Output = <Saturating<i128> as Mul<Saturating<i128>>>::Output

impl Mul<&Saturating<isize>> for &Saturating<isize>

type Output = <Saturating<isize> as Mul<Saturating<isize>>>::Output

impl Mul<&Saturating<isize>> for Saturating<isize>

type Output = <Saturating<isize> as Mul<Saturating<isize>>>::Output

impl Mul<&Saturating<u8>> for &Saturating<u8>

type Output = <Saturating<u8> as Mul<Saturating<u8>>>::Output

impl Mul<&Saturating<u8>> for Saturating<u8>

type Output = <Saturating<u8> as Mul<Saturating<u8>>>::Output

impl Mul<&Saturating<u16>> for &Saturating<u16>

type Output = <Saturating<u16> as Mul<Saturating<u16>>>::Output

impl Mul<&Saturating<u16>> for Saturating<u16>

type Output = <Saturating<u16> as Mul<Saturating<u16>>>::Output

impl Mul<&Saturating<u32>> for &Saturating<u32>

type Output = <Saturating<u32> as Mul<Saturating<u32>>>::Output

impl Mul<&Saturating<u32>> for Saturating<u32>

type Output = <Saturating<u32> as Mul<Saturating<u32>>>::Output

impl Mul<&Saturating<u64>> for &Saturating<u64>

type Output = <Saturating<u64> as Mul<Saturating<u64>>>::Output

impl Mul<&Saturating<u64>> for Saturating<u64>

type Output = <Saturating<u64> as Mul<Saturating<u64>>>::Output

impl Mul<&Saturating<u128>> for &Saturating<u128>

type Output = <Saturating<u128> as Mul<Saturating<u128>>>::Output

impl Mul<&Saturating<u128>> for Saturating<u128>

type Output = <Saturating<u128> as Mul<Saturating<u128>>>::Output

impl Mul<&Saturating<usize>> for &Saturating<usize>

type Output = <Saturating<usize> as Mul<Saturating<usize>>>::Output

impl Mul<&Saturating<usize>> for Saturating<usize>

type Output = <Saturating<usize> as Mul<Saturating<usize>>>::Output

impl Mul<&Wrapping<i8>> for &Wrapping<i8>

type Output = <Wrapping<i8> as Mul<Wrapping<i8>>>::Output

impl Mul<&Wrapping<i8>> for Wrapping<i8>

type Output = <Wrapping<i8> as Mul<Wrapping<i8>>>::Output

impl Mul<&Wrapping<i16>> for &Wrapping<i16>

type Output = <Wrapping<i16> as Mul<Wrapping<i16>>>::Output

impl Mul<&Wrapping<i16>> for Wrapping<i16>

type Output = <Wrapping<i16> as Mul<Wrapping<i16>>>::Output

impl Mul<&Wrapping<i32>> for &Wrapping<i32>

type Output = <Wrapping<i32> as Mul<Wrapping<i32>>>::Output

impl Mul<&Wrapping<i32>> for Wrapping<i32>

type Output = <Wrapping<i32> as Mul<Wrapping<i32>>>::Output

impl Mul<&Wrapping<i64>> for &Wrapping<i64>

type Output = <Wrapping<i64> as Mul<Wrapping<i64>>>::Output

impl Mul<&Wrapping<i64>> for Wrapping<i64>

type Output = <Wrapping<i64> as Mul<Wrapping<i64>>>::Output

impl Mul<&Wrapping<i128>> for &Wrapping<i128>

type Output = <Wrapping<i128> as Mul<Wrapping<i128>>>::Output

impl Mul<&Wrapping<i128>> for Wrapping<i128>

type Output = <Wrapping<i128> as Mul<Wrapping<i128>>>::Output

impl Mul<&Wrapping<isize>> for &Wrapping<isize>

type Output = <Wrapping<isize> as Mul<Wrapping<isize>>>::Output

impl Mul<&Wrapping<isize>> for Wrapping<isize>

type Output = <Wrapping<isize> as Mul<Wrapping<isize>>>::Output

impl Mul<&Wrapping<u8>> for &Wrapping<u8>

type Output = <Wrapping<u8> as Mul<Wrapping<u8>>>::Output

impl Mul<&Wrapping<u8>> for Wrapping<u8>

type Output = <Wrapping<u8> as Mul<Wrapping<u8>>>::Output

impl Mul<&Wrapping<u16>> for &Wrapping<u16>

type Output = <Wrapping<u16> as Mul<Wrapping<u16>>>::Output

impl Mul<&Wrapping<u16>> for Wrapping<u16>

type Output = <Wrapping<u16> as Mul<Wrapping<u16>>>::Output

impl Mul<&Wrapping<u32>> for &Wrapping<u32>

type Output = <Wrapping<u32> as Mul<Wrapping<u32>>>::Output

impl Mul<&Wrapping<u32>> for Wrapping<u32>

type Output = <Wrapping<u32> as Mul<Wrapping<u32>>>::Output

impl Mul<&Wrapping<u64>> for &Wrapping<u64>

type Output = <Wrapping<u64> as Mul<Wrapping<u64>>>::Output

impl Mul<&Wrapping<u64>> for Wrapping<u64>

type Output = <Wrapping<u64> as Mul<Wrapping<u64>>>::Output

impl Mul<&Wrapping<u128>> for &Wrapping<u128>

type Output = <Wrapping<u128> as Mul<Wrapping<u128>>>::Output

impl Mul<&Wrapping<u128>> for Wrapping<u128>

type Output = <Wrapping<u128> as Mul<Wrapping<u128>>>::Output

impl Mul<&Wrapping<usize>> for &Wrapping<usize>

type Output = <Wrapping<usize> as Mul<Wrapping<usize>>>::Output

impl Mul<&Wrapping<usize>> for Wrapping<usize>

type Output = <Wrapping<usize> as Mul<Wrapping<usize>>>::Output

impl Mul<&Mat> for &f64

type Output = MatExprResult<MatExpr>

impl Mul<&Mat> for &Mat

type Output = MatExprResult<MatExpr>

impl Mul<&Mat> for &MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<&Mat> for MatExprResult<&f64>

type Output = MatExprResult<MatExpr>

impl Mul<&Mat> for MatExprResult<&Mat>

type Output = MatExprResult<MatExpr>

impl Mul<&Mat> for MatExprResult<&MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<&Mat> for MatExprResult<f64>

type Output = MatExprResult<MatExpr>

impl Mul<&Mat> for MatExprResult<Mat>

type Output = MatExprResult<MatExpr>

impl Mul<&Mat> for MatExprResult<MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<&Mat> for f64

type Output = MatExprResult<MatExpr>

impl Mul<&Mat> for Mat

type Output = MatExprResult<MatExpr>

impl Mul<&Mat> for MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<&MatExpr> for &f64

type Output = MatExprResult<MatExpr>

impl Mul<&MatExpr> for &Mat

type Output = MatExprResult<MatExpr>

impl Mul<&MatExpr> for &MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<&MatExpr> for MatExprResult<&f64>

type Output = MatExprResult<MatExpr>

impl Mul<&MatExpr> for MatExprResult<&Mat>

type Output = MatExprResult<MatExpr>

impl Mul<&MatExpr> for MatExprResult<&MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<&MatExpr> for MatExprResult<f64>

type Output = MatExprResult<MatExpr>

impl Mul<&MatExpr> for MatExprResult<Mat>

type Output = MatExprResult<MatExpr>

impl Mul<&MatExpr> for MatExprResult<MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<&MatExpr> for f64

type Output = MatExprResult<MatExpr>

impl Mul<&MatExpr> for Mat

type Output = MatExprResult<MatExpr>

impl Mul<&MatExpr> for MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<&bf16> for &bf16

type Output = <bf16 as Mul<bf16>>::Output

impl Mul<&bf16> for bf16

type Output = <bf16 as Mul<bf16>>::Output

impl Mul<&f16> for &f16

type Output = <f16 as Mul<f16>>::Output

impl Mul<&f16> for f16

type Output = <f16 as Mul<f16>>::Output

impl Mul<&f32x4> for f32x4

type Output = f32x4

impl Mul<&f32x8> for f32x8

type Output = f32x8

impl Mul<&f64x2> for f64x2

type Output = f64x2

impl Mul<&f64x4> for f64x4

type Output = f64x4

impl Mul<&i16x8> for i16x8

type Output = i16x8

impl Mul<&i16x16> for i16x16

type Output = i16x16

impl Mul<&i32x4> for i32x4

type Output = i32x4

impl Mul<&i32x8> for i32x8

type Output = i32x8

impl Mul<MatExprResult<&f64>> for &Mat

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&f64>> for &MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&f64>> for MatExprResult<&Mat>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&f64>> for MatExprResult<&MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&f64>> for MatExprResult<Mat>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&f64>> for MatExprResult<MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&f64>> for Mat

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&f64>> for MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&Mat>> for &f64

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&Mat>> for &Mat

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&Mat>> for &MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&Mat>> for MatExprResult<&f64>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&Mat>> for MatExprResult<&Mat>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&Mat>> for MatExprResult<&MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&Mat>> for MatExprResult<f64>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&Mat>> for MatExprResult<Mat>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&Mat>> for MatExprResult<MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&Mat>> for f64

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&Mat>> for Mat

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&Mat>> for MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&MatExpr>> for &f64

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&MatExpr>> for &Mat

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&MatExpr>> for &MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&MatExpr>> for MatExprResult<&f64>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&MatExpr>> for MatExprResult<&Mat>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&MatExpr>> for MatExprResult<&MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&MatExpr>> for MatExprResult<f64>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&MatExpr>> for MatExprResult<Mat>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&MatExpr>> for MatExprResult<MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&MatExpr>> for f64

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&MatExpr>> for Mat

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<&MatExpr>> for MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<f64>> for &Mat

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<f64>> for &MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<f64>> for MatExprResult<&Mat>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<f64>> for MatExprResult<&MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<f64>> for MatExprResult<Mat>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<f64>> for MatExprResult<MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<f64>> for Mat

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<f64>> for MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<Mat>> for &f64

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<Mat>> for &Mat

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<Mat>> for &MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<Mat>> for MatExprResult<&f64>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<Mat>> for MatExprResult<&Mat>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<Mat>> for MatExprResult<&MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<Mat>> for MatExprResult<f64>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<Mat>> for MatExprResult<Mat>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<Mat>> for MatExprResult<MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<Mat>> for f64

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<Mat>> for Mat

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<Mat>> for MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<MatExpr>> for &f64

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<MatExpr>> for &Mat

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<MatExpr>> for &MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<MatExpr>> for MatExprResult<&f64>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<MatExpr>> for MatExprResult<&Mat>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<MatExpr>> for MatExprResult<&MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<MatExpr>> for MatExprResult<f64>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<MatExpr>> for MatExprResult<Mat>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<MatExpr>> for MatExprResult<MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<MatExpr>> for f64

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<MatExpr>> for Mat

type Output = MatExprResult<MatExpr>

impl Mul<MatExprResult<MatExpr>> for MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<Sign> for Sign

type Output = Sign

impl Mul<f32> for f32

type Output = f32

impl Mul<f32> for f32x4

type Output = f32x4

impl Mul<f32> for f32x8

type Output = f32x8

impl Mul<f64> for &Mat

type Output = MatExprResult<MatExpr>

impl Mul<f64> for &MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<f64> for MatExprResult<&Mat>

type Output = MatExprResult<MatExpr>

impl Mul<f64> for MatExprResult<&MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<f64> for MatExprResult<Mat>

type Output = MatExprResult<MatExpr>

impl Mul<f64> for MatExprResult<MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<f64> for f64

type Output = f64

impl Mul<f64> for Mat

type Output = MatExprResult<MatExpr>

impl Mul<f64> for MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<f64> for f64x2

type Output = f64x2

impl Mul<f64> for f64x4

type Output = f64x4

impl Mul<i8> for i8

type Output = i8

impl Mul<i8> for BigInt

type Output = BigInt

impl Mul<i16> for i16

type Output = i16

impl Mul<i16> for BigInt

type Output = BigInt

impl Mul<i16> for i16x8

type Output = i16x8

impl Mul<i16> for i16x16

type Output = i16x16

impl Mul<i32> for i32

type Output = i32

impl Mul<i32> for BigInt

type Output = BigInt

impl Mul<i32> for i32x4

type Output = i32x4

impl Mul<i32> for i32x8

type Output = i32x8

impl Mul<i64> for i64

type Output = i64

impl Mul<i64> for BigInt

type Output = BigInt

impl Mul<i64> for i64x2

type Output = i64x2

impl Mul<i64> for i64x4

type Output = i64x4

impl Mul<i128> for i128

type Output = i128

impl Mul<i128> for BigInt

type Output = BigInt

impl Mul<isize> for isize

type Output = isize

impl Mul<isize> for BigInt

type Output = BigInt

impl Mul<u8> for u8

type Output = u8

impl Mul<u8> for BigInt

type Output = BigInt

impl Mul<u8> for BigUint

type Output = BigUint

impl Mul<u16> for u16

type Output = u16

impl Mul<u16> for BigInt

type Output = BigInt

impl Mul<u16> for BigUint

type Output = BigUint

impl Mul<u16> for u16x8

type Output = u16x8

impl Mul<u32> for u32

type Output = u32

impl Mul<u32> for Duration

type Output = Duration

impl Mul<u32> for BigInt

type Output = BigInt

impl Mul<u32> for BigUint

type Output = BigUint

impl Mul<u32> for u32x4

type Output = u32x4

impl Mul<u64> for u64

type Output = u64

impl Mul<u64> for BigInt

type Output = BigInt

impl Mul<u64> for BigUint

type Output = BigUint

impl Mul<u64> for u64x2

type Output = u64x2

impl Mul<u64> for u64x4

type Output = u64x4

impl Mul<u128> for u128

type Output = u128

impl Mul<u128> for BigInt

type Output = BigInt

impl Mul<u128> for BigUint

type Output = BigUint

impl Mul<usize> for usize

type Output = usize

impl Mul<usize> for BigInt

type Output = BigInt

impl Mul<usize> for BigUint

type Output = BigUint

impl Mul<Saturating<i8>> for Saturating<i8>

type Output = Saturating<i8>

impl Mul<Saturating<i16>> for Saturating<i16>

type Output = Saturating<i16>

impl Mul<Saturating<i32>> for Saturating<i32>

type Output = Saturating<i32>

impl Mul<Saturating<i64>> for Saturating<i64>

type Output = Saturating<i64>

impl Mul<Saturating<i128>> for Saturating<i128>

type Output = Saturating<i128>

impl Mul<Saturating<isize>> for Saturating<isize>

type Output = Saturating<isize>

impl Mul<Saturating<u8>> for Saturating<u8>

type Output = Saturating<u8>

impl Mul<Saturating<u16>> for Saturating<u16>

type Output = Saturating<u16>

impl Mul<Saturating<u32>> for Saturating<u32>

type Output = Saturating<u32>

impl Mul<Saturating<u64>> for Saturating<u64>

type Output = Saturating<u64>

impl Mul<Saturating<u128>> for Saturating<u128>

type Output = Saturating<u128>

impl Mul<Saturating<usize>> for Saturating<usize>

type Output = Saturating<usize>

impl Mul<Wrapping<i8>> for Wrapping<i8>

type Output = Wrapping<i8>

impl Mul<Wrapping<i16>> for Wrapping<i16>

type Output = Wrapping<i16>

impl Mul<Wrapping<i32>> for Wrapping<i32>

type Output = Wrapping<i32>

impl Mul<Wrapping<i64>> for Wrapping<i64>

type Output = Wrapping<i64>

impl Mul<Wrapping<i128>> for Wrapping<i128>

type Output = Wrapping<i128>

impl Mul<Wrapping<isize>> for Wrapping<isize>

type Output = Wrapping<isize>

impl Mul<Wrapping<u8>> for Wrapping<u8>

type Output = Wrapping<u8>

impl Mul<Wrapping<u16>> for Wrapping<u16>

type Output = Wrapping<u16>

impl Mul<Wrapping<u32>> for Wrapping<u32>

type Output = Wrapping<u32>

impl Mul<Wrapping<u64>> for Wrapping<u64>

type Output = Wrapping<u64>

impl Mul<Wrapping<u128>> for Wrapping<u128>

type Output = Wrapping<u128>

impl Mul<Wrapping<usize>> for Wrapping<usize>

type Output = Wrapping<usize>

impl Mul<Duration> for u32

type Output = Duration

impl Mul<Mat> for &f64

type Output = MatExprResult<MatExpr>

impl Mul<Mat> for &Mat

type Output = MatExprResult<MatExpr>

impl Mul<Mat> for &MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<Mat> for MatExprResult<&f64>

type Output = MatExprResult<MatExpr>

impl Mul<Mat> for MatExprResult<&Mat>

type Output = MatExprResult<MatExpr>

impl Mul<Mat> for MatExprResult<&MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<Mat> for MatExprResult<f64>

type Output = MatExprResult<MatExpr>

impl Mul<Mat> for MatExprResult<Mat>

type Output = MatExprResult<MatExpr>

impl Mul<Mat> for MatExprResult<MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<Mat> for f64

type Output = MatExprResult<MatExpr>

impl Mul<Mat> for Mat

type Output = MatExprResult<MatExpr>

impl Mul<Mat> for MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<MatExpr> for &f64

type Output = MatExprResult<MatExpr>

impl Mul<MatExpr> for &Mat

type Output = MatExprResult<MatExpr>

impl Mul<MatExpr> for &MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<MatExpr> for MatExprResult<&f64>

type Output = MatExprResult<MatExpr>

impl Mul<MatExpr> for MatExprResult<&Mat>

type Output = MatExprResult<MatExpr>

impl Mul<MatExpr> for MatExprResult<&MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<MatExpr> for MatExprResult<f64>

type Output = MatExprResult<MatExpr>

impl Mul<MatExpr> for MatExprResult<Mat>

type Output = MatExprResult<MatExpr>

impl Mul<MatExpr> for MatExprResult<MatExpr>

type Output = MatExprResult<MatExpr>

impl Mul<MatExpr> for f64

type Output = MatExprResult<MatExpr>

impl Mul<MatExpr> for Mat

type Output = MatExprResult<MatExpr>

impl Mul<MatExpr> for MatExpr

type Output = MatExprResult<MatExpr>

impl Mul<DualQuaternion<f32>> for f32

type Output = DualQuaternion<f32>

impl Mul<DualQuaternion<f64>> for f64

type Output = DualQuaternion<f64>

impl Mul<Quaternion<f32>> for f32

type Output = Quaternion<f32>

impl Mul<Quaternion<f64>> for f64

type Output = Quaternion<f64>

impl Mul<BigInt> for i8

type Output = BigInt

impl Mul<BigInt> for i16

type Output = BigInt

impl Mul<BigInt> for i32

type Output = BigInt

impl Mul<BigInt> for i64

type Output = BigInt

impl Mul<BigInt> for i128

type Output = BigInt

impl Mul<BigInt> for isize

type Output = BigInt

impl Mul<BigInt> for u8

type Output = BigInt

impl Mul<BigInt> for u16

type Output = BigInt

impl Mul<BigInt> for u32

type Output = BigInt

impl Mul<BigInt> for u64

type Output = BigInt

impl Mul<BigInt> for u128

type Output = BigInt

impl Mul<BigInt> for usize

type Output = BigInt

impl Mul<BigInt> for BigInt

type Output = BigInt

impl Mul<BigUint> for u8

type Output = BigUint

impl Mul<BigUint> for u16

type Output = BigUint

impl Mul<BigUint> for u32

type Output = BigUint

impl Mul<BigUint> for u64

type Output = BigUint

impl Mul<BigUint> for u128

type Output = BigUint

impl Mul<BigUint> for usize

type Output = BigUint

impl Mul<BigUint> for BigUint

type Output = BigUint

impl Mul<ATerm> for Z0

type Output = ATerm

impl Mul<B0> for UTerm

UTerm * B0 = UTerm

type Output = UTerm

impl Mul<B1> for UTerm

UTerm * B1 = UTerm

type Output = UTerm

impl Mul<Complex<f32>> for f32

type Output = Complex<f32>

impl Mul<Complex<f64>> for f64

type Output = Complex<f64>

impl Mul<Complex<i8>> for i8

type Output = Complex<i8>

impl Mul<Complex<i16>> for i16

type Output = Complex<i16>

impl Mul<Complex<i32>> for i32

type Output = Complex<i32>

impl Mul<Complex<i64>> for i64

type Output = Complex<i64>

impl Mul<Complex<i128>> for i128

type Output = Complex<i128>

impl Mul<Complex<isize>> for isize

type Output = Complex<isize>

impl Mul<Complex<u8>> for u8

type Output = Complex<u8>

impl Mul<Complex<u16>> for u16

type Output = Complex<u16>

impl Mul<Complex<u32>> for u32

type Output = Complex<u32>

impl Mul<Complex<u64>> for u64

type Output = Complex<u64>

impl Mul<Complex<u128>> for u128

type Output = Complex<u128>

impl Mul<Complex<usize>> for usize

type Output = Complex<usize>

impl Mul<bf16> for &bf16

type Output = <bf16 as Mul<bf16>>::Output

impl Mul<bf16> for bf16

type Output = bf16

impl Mul<f16> for &f16

type Output = <f16 as Mul<f16>>::Output

impl Mul<f16> for f16

type Output = f16

impl Mul<AutoSimd<[f32; 2]>> for AutoSimd<[f32; 2]>

type Output = AutoSimd<[f32; 2]>

impl Mul<AutoSimd<[f32; 4]>> for AutoSimd<[f32; 4]>

type Output = AutoSimd<[f32; 4]>

impl Mul<AutoSimd<[f32; 8]>> for AutoSimd<[f32; 8]>

type Output = AutoSimd<[f32; 8]>

impl Mul<AutoSimd<[f32; 16]>> for AutoSimd<[f32; 16]>

type Output = AutoSimd<[f32; 16]>

impl Mul<AutoSimd<[f64; 2]>> for AutoSimd<[f64; 2]>

type Output = AutoSimd<[f64; 2]>

impl Mul<AutoSimd<[f64; 4]>> for AutoSimd<[f64; 4]>

type Output = AutoSimd<[f64; 4]>

impl Mul<AutoSimd<[f64; 8]>> for AutoSimd<[f64; 8]>

type Output = AutoSimd<[f64; 8]>

impl Mul<AutoSimd<[i8; 2]>> for AutoSimd<[i8; 2]>

type Output = AutoSimd<[i8; 2]>

impl Mul<AutoSimd<[i8; 4]>> for AutoSimd<[i8; 4]>

type Output = AutoSimd<[i8; 4]>

impl Mul<AutoSimd<[i8; 8]>> for AutoSimd<[i8; 8]>

type Output = AutoSimd<[i8; 8]>

impl Mul<AutoSimd<[i8; 16]>> for AutoSimd<[i8; 16]>

type Output = AutoSimd<[i8; 16]>

impl Mul<AutoSimd<[i8; 32]>> for AutoSimd<[i8; 32]>

type Output = AutoSimd<[i8; 32]>

impl Mul<AutoSimd<[i16; 2]>> for AutoSimd<[i16; 2]>

type Output = AutoSimd<[i16; 2]>

impl Mul<AutoSimd<[i16; 4]>> for AutoSimd<[i16; 4]>

type Output = AutoSimd<[i16; 4]>

impl Mul<AutoSimd<[i16; 8]>> for AutoSimd<[i16; 8]>

type Output = AutoSimd<[i16; 8]>

impl Mul<AutoSimd<[i16; 16]>> for AutoSimd<[i16; 16]>

type Output = AutoSimd<[i16; 16]>

impl Mul<AutoSimd<[i16; 32]>> for AutoSimd<[i16; 32]>

type Output = AutoSimd<[i16; 32]>

impl Mul<AutoSimd<[i32; 2]>> for AutoSimd<[i32; 2]>

type Output = AutoSimd<[i32; 2]>

impl Mul<AutoSimd<[i32; 4]>> for AutoSimd<[i32; 4]>

type Output = AutoSimd<[i32; 4]>

impl Mul<AutoSimd<[i32; 8]>> for AutoSimd<[i32; 8]>

type Output = AutoSimd<[i32; 8]>

impl Mul<AutoSimd<[i32; 16]>> for AutoSimd<[i32; 16]>

type Output = AutoSimd<[i32; 16]>

impl Mul<AutoSimd<[i64; 2]>> for AutoSimd<[i64; 2]>

type Output = AutoSimd<[i64; 2]>

impl Mul<AutoSimd<[i64; 4]>> for AutoSimd<[i64; 4]>

type Output = AutoSimd<[i64; 4]>

impl Mul<AutoSimd<[i64; 8]>> for AutoSimd<[i64; 8]>

type Output = AutoSimd<[i64; 8]>

impl Mul<AutoSimd<[i128; 1]>> for AutoSimd<[i128; 1]>

type Output = AutoSimd<[i128; 1]>

impl Mul<AutoSimd<[i128; 2]>> for AutoSimd<[i128; 2]>

type Output = AutoSimd<[i128; 2]>

impl Mul<AutoSimd<[i128; 4]>> for AutoSimd<[i128; 4]>

type Output = AutoSimd<[i128; 4]>

impl Mul<AutoSimd<[isize; 2]>> for AutoSimd<[isize; 2]>

type Output = AutoSimd<[isize; 2]>

impl Mul<AutoSimd<[isize; 4]>> for AutoSimd<[isize; 4]>

type Output = AutoSimd<[isize; 4]>

impl Mul<AutoSimd<[isize; 8]>> for AutoSimd<[isize; 8]>

type Output = AutoSimd<[isize; 8]>

impl Mul<AutoSimd<[u8; 2]>> for AutoSimd<[u8; 2]>

type Output = AutoSimd<[u8; 2]>

impl Mul<AutoSimd<[u8; 4]>> for AutoSimd<[u8; 4]>

type Output = AutoSimd<[u8; 4]>

impl Mul<AutoSimd<[u8; 8]>> for AutoSimd<[u8; 8]>

type Output = AutoSimd<[u8; 8]>

impl Mul<AutoSimd<[u8; 16]>> for AutoSimd<[u8; 16]>

type Output = AutoSimd<[u8; 16]>

impl Mul<AutoSimd<[u8; 32]>> for AutoSimd<[u8; 32]>

type Output = AutoSimd<[u8; 32]>

impl Mul<AutoSimd<[u16; 2]>> for AutoSimd<[u16; 2]>

type Output = AutoSimd<[u16; 2]>

impl Mul<AutoSimd<[u16; 4]>> for AutoSimd<[u16; 4]>

type Output = AutoSimd<[u16; 4]>

impl Mul<AutoSimd<[u16; 8]>> for AutoSimd<[u16; 8]>

type Output = AutoSimd<[u16; 8]>

impl Mul<AutoSimd<[u16; 16]>> for AutoSimd<[u16; 16]>

type Output = AutoSimd<[u16; 16]>

impl Mul<AutoSimd<[u16; 32]>> for AutoSimd<[u16; 32]>

type Output = AutoSimd<[u16; 32]>

impl Mul<AutoSimd<[u32; 2]>> for AutoSimd<[u32; 2]>

type Output = AutoSimd<[u32; 2]>

impl Mul<AutoSimd<[u32; 4]>> for AutoSimd<[u32; 4]>

type Output = AutoSimd<[u32; 4]>

impl Mul<AutoSimd<[u32; 8]>> for AutoSimd<[u32; 8]>

type Output = AutoSimd<[u32; 8]>

impl Mul<AutoSimd<[u32; 16]>> for AutoSimd<[u32; 16]>

type Output = AutoSimd<[u32; 16]>

impl Mul<AutoSimd<[u64; 2]>> for AutoSimd<[u64; 2]>

type Output = AutoSimd<[u64; 2]>

impl Mul<AutoSimd<[u64; 4]>> for AutoSimd<[u64; 4]>

type Output = AutoSimd<[u64; 4]>

impl Mul<AutoSimd<[u64; 8]>> for AutoSimd<[u64; 8]>

type Output = AutoSimd<[u64; 8]>

impl Mul<AutoSimd<[u128; 1]>> for AutoSimd<[u128; 1]>

type Output = AutoSimd<[u128; 1]>

impl Mul<AutoSimd<[u128; 2]>> for AutoSimd<[u128; 2]>

type Output = AutoSimd<[u128; 2]>

impl Mul<AutoSimd<[u128; 4]>> for AutoSimd<[u128; 4]>

type Output = AutoSimd<[u128; 4]>

impl Mul<AutoSimd<[usize; 2]>> for AutoSimd<[usize; 2]>

type Output = AutoSimd<[usize; 2]>

impl Mul<AutoSimd<[usize; 4]>> for AutoSimd<[usize; 4]>

type Output = AutoSimd<[usize; 4]>

impl Mul<AutoSimd<[usize; 8]>> for AutoSimd<[usize; 8]>

type Output = AutoSimd<[usize; 8]>

impl Mul<WideF32x4> for WideF32x4

type Output = WideF32x4

impl Mul<f32x4> for f32

type Output = f32x4

impl Mul<f32x4> for f32x4

type Output = f32x4

impl Mul<f32x8> for f32

type Output = f32x8

impl Mul<f32x8> for f32x8

type Output = f32x8

impl Mul<f64x2> for f64

type Output = f64x2

impl Mul<f64x2> for f64x2

type Output = f64x2

impl Mul<f64x4> for f64

type Output = f64x4

impl Mul<f64x4> for f64x4

type Output = f64x4

impl Mul<i16x8> for i16

type Output = i16x8

impl Mul<i16x8> for i16x8

type Output = i16x8

impl Mul<i16x16> for i16

type Output = i16x16

impl Mul<i16x16> for i16x16

type Output = i16x16

impl Mul<i32x4> for i32

type Output = i32x4

impl Mul<i32x4> for i32x4

type Output = i32x4

impl Mul<i32x8> for i32

type Output = i32x8

impl Mul<i32x8> for i32x8

type Output = i32x8

impl Mul<i64x2> for i64

type Output = i64x2

impl Mul<i64x2> for i64x2

type Output = i64x2

impl Mul<i64x4> for i64

type Output = i64x4

impl Mul<i64x4> for i64x4

type Output = i64x4

impl Mul<m128> for m128

type Output = m128

impl Mul<m128d> for m128d

type Output = m128d

impl Mul<u16x8> for u16

type Output = u16x8

impl Mul<u16x8> for u16x8

type Output = u16x8

impl Mul<u32x4> for u32

type Output = u32x4

impl Mul<u32x4> for u32x4

type Output = u32x4

impl Mul<u32x8> for u32x8

type Output = u32x8

impl Mul<u64x2> for u64

type Output = u64x2

impl Mul<u64x2> for u64x2

type Output = u64x2

impl Mul<u64x4> for u64

type Output = u64x4

impl Mul<u64x4> for u64x4

type Output = u64x4

impl<'a> Mul<&'a i8> for BigInt

type Output = BigInt

impl<'a> Mul<&'a i16> for BigInt

type Output = BigInt

impl<'a> Mul<&'a i32> for BigInt

type Output = BigInt

impl<'a> Mul<&'a i64> for BigInt

type Output = BigInt

impl<'a> Mul<&'a i128> for BigInt

type Output = BigInt

impl<'a> Mul<&'a isize> for BigInt

type Output = BigInt

impl<'a> Mul<&'a u8> for BigInt

type Output = BigInt

impl<'a> Mul<&'a u8> for BigUint

type Output = BigUint

impl<'a> Mul<&'a u16> for BigInt

type Output = BigInt

impl<'a> Mul<&'a u16> for BigUint

type Output = BigUint

impl<'a> Mul<&'a u32> for BigInt

type Output = BigInt

impl<'a> Mul<&'a u32> for BigUint

type Output = BigUint

impl<'a> Mul<&'a u64> for BigInt

type Output = BigInt

impl<'a> Mul<&'a u64> for BigUint

type Output = BigUint

impl<'a> Mul<&'a u128> for BigInt

type Output = BigInt

impl<'a> Mul<&'a u128> for BigUint

type Output = BigUint

impl<'a> Mul<&'a usize> for BigInt

type Output = BigInt

impl<'a> Mul<&'a usize> for BigUint

type Output = BigUint

impl<'a> Mul<&'a BigInt> for i8

type Output = BigInt

impl<'a> Mul<&'a BigInt> for i16

type Output = BigInt

impl<'a> Mul<&'a BigInt> for i32

type Output = BigInt

impl<'a> Mul<&'a BigInt> for i64

type Output = BigInt

impl<'a> Mul<&'a BigInt> for i128

type Output = BigInt

impl<'a> Mul<&'a BigInt> for isize

type Output = BigInt

impl<'a> Mul<&'a BigInt> for u8

type Output = BigInt

impl<'a> Mul<&'a BigInt> for u16

type Output = BigInt

impl<'a> Mul<&'a BigInt> for u32

type Output = BigInt

impl<'a> Mul<&'a BigInt> for u64

type Output = BigInt

impl<'a> Mul<&'a BigInt> for u128

type Output = BigInt

impl<'a> Mul<&'a BigInt> for usize

type Output = BigInt

impl<'a> Mul<&'a BigUint> for u8

type Output = BigUint

impl<'a> Mul<&'a BigUint> for u16

type Output = BigUint

impl<'a> Mul<&'a BigUint> for u32

type Output = BigUint

impl<'a> Mul<&'a BigUint> for u64

type Output = BigUint

impl<'a> Mul<&'a BigUint> for u128

type Output = BigUint

impl<'a> Mul<&'a BigUint> for usize

type Output = BigUint

impl<'a> Mul<&'a Complex<f32>> for f32

type Output = Complex<f32>

impl<'a> Mul<&'a Complex<f64>> for f64

type Output = Complex<f64>

impl<'a> Mul<&'a Complex<i8>> for i8

type Output = Complex<i8>

impl<'a> Mul<&'a Complex<i16>> for i16

type Output = Complex<i16>

impl<'a> Mul<&'a Complex<i32>> for i32

type Output = Complex<i32>

impl<'a> Mul<&'a Complex<i64>> for i64

type Output = Complex<i64>

impl<'a> Mul<&'a Complex<i128>> for i128

type Output = Complex<i128>

impl<'a> Mul<&'a Complex<isize>> for isize

type Output = Complex<isize>

impl<'a> Mul<&'a Complex<u8>> for u8

type Output = Complex<u8>

impl<'a> Mul<&'a Complex<u16>> for u16

type Output = Complex<u16>

impl<'a> Mul<&'a Complex<u32>> for u32

type Output = Complex<u32>

impl<'a> Mul<&'a Complex<u64>> for u64

type Output = Complex<u64>

impl<'a> Mul<&'a Complex<u128>> for u128

type Output = Complex<u128>

impl<'a> Mul<&'a Complex<usize>> for usize

type Output = Complex<usize>

impl<'a> Mul<f32> for &'a f32

type Output = <f32 as Mul<f32>>::Output

impl<'a> Mul<f64> for &'a f64

type Output = <f64 as Mul<f64>>::Output

impl<'a> Mul<i8> for &'a i8

type Output = <i8 as Mul<i8>>::Output

impl<'a> Mul<i8> for &'a BigInt

type Output = BigInt

impl<'a> Mul<i16> for &'a i16

type Output = <i16 as Mul<i16>>::Output

impl<'a> Mul<i16> for &'a BigInt

type Output = BigInt

impl<'a> Mul<i32> for &'a i32

type Output = <i32 as Mul<i32>>::Output

impl<'a> Mul<i32> for &'a BigInt

type Output = BigInt

impl<'a> Mul<i64> for &'a i64

type Output = <i64 as Mul<i64>>::Output

impl<'a> Mul<i64> for &'a BigInt

type Output = BigInt

impl<'a> Mul<i128> for &'a i128

type Output = <i128 as Mul<i128>>::Output

impl<'a> Mul<i128> for &'a BigInt

type Output = BigInt

impl<'a> Mul<isize> for &'a isize

type Output = <isize as Mul<isize>>::Output

impl<'a> Mul<isize> for &'a BigInt

type Output = BigInt

impl<'a> Mul<u8> for &'a u8

type Output = <u8 as Mul<u8>>::Output

impl<'a> Mul<u8> for &'a BigInt

type Output = BigInt

impl<'a> Mul<u8> for &'a BigUint

type Output = BigUint

impl<'a> Mul<u16> for &'a u16

type Output = <u16 as Mul<u16>>::Output

impl<'a> Mul<u16> for &'a BigInt

type Output = BigInt

impl<'a> Mul<u16> for &'a BigUint

type Output = BigUint

impl<'a> Mul<u32> for &'a u32

type Output = <u32 as Mul<u32>>::Output

impl<'a> Mul<u32> for &'a BigInt

type Output = BigInt

impl<'a> Mul<u32> for &'a BigUint

type Output = BigUint

impl<'a> Mul<u64> for &'a u64

type Output = <u64 as Mul<u64>>::Output

impl<'a> Mul<u64> for &'a BigInt

type Output = BigInt

impl<'a> Mul<u64> for &'a BigUint

type Output = BigUint

impl<'a> Mul<u128> for &'a u128

type Output = <u128 as Mul<u128>>::Output

impl<'a> Mul<u128> for &'a BigInt

type Output = BigInt

impl<'a> Mul<u128> for &'a BigUint

type Output = BigUint

impl<'a> Mul<usize> for &'a usize

type Output = <usize as Mul<usize>>::Output

impl<'a> Mul<usize> for &'a BigInt

type Output = BigInt

impl<'a> Mul<usize> for &'a BigUint

type Output = BigUint

impl<'a> Mul<Saturating<i8>> for &'a Saturating<i8>

type Output = <Saturating<i8> as Mul<Saturating<i8>>>::Output

impl<'a> Mul<Saturating<i16>> for &'a Saturating<i16>

type Output = <Saturating<i16> as Mul<Saturating<i16>>>::Output

impl<'a> Mul<Saturating<i32>> for &'a Saturating<i32>

type Output = <Saturating<i32> as Mul<Saturating<i32>>>::Output

impl<'a> Mul<Saturating<i64>> for &'a Saturating<i64>

type Output = <Saturating<i64> as Mul<Saturating<i64>>>::Output

impl<'a> Mul<Saturating<i128>> for &'a Saturating<i128>

type Output = <Saturating<i128> as Mul<Saturating<i128>>>::Output

impl<'a> Mul<Saturating<isize>> for &'a Saturating<isize>

type Output = <Saturating<isize> as Mul<Saturating<isize>>>::Output

impl<'a> Mul<Saturating<u8>> for &'a Saturating<u8>

type Output = <Saturating<u8> as Mul<Saturating<u8>>>::Output

impl<'a> Mul<Saturating<u16>> for &'a Saturating<u16>

type Output = <Saturating<u16> as Mul<Saturating<u16>>>::Output

impl<'a> Mul<Saturating<u32>> for &'a Saturating<u32>

type Output = <Saturating<u32> as Mul<Saturating<u32>>>::Output

impl<'a> Mul<Saturating<u64>> for &'a Saturating<u64>

type Output = <Saturating<u64> as Mul<Saturating<u64>>>::Output

impl<'a> Mul<Saturating<u128>> for &'a Saturating<u128>

type Output = <Saturating<u128> as Mul<Saturating<u128>>>::Output

impl<'a> Mul<Saturating<usize>> for &'a Saturating<usize>

type Output = <Saturating<usize> as Mul<Saturating<usize>>>::Output

impl<'a> Mul<Wrapping<i8>> for &'a Wrapping<i8>

type Output = <Wrapping<i8> as Mul<Wrapping<i8>>>::Output

impl<'a> Mul<Wrapping<i16>> for &'a Wrapping<i16>

type Output = <Wrapping<i16> as Mul<Wrapping<i16>>>::Output

impl<'a> Mul<Wrapping<i32>> for &'a Wrapping<i32>

type Output = <Wrapping<i32> as Mul<Wrapping<i32>>>::Output

impl<'a> Mul<Wrapping<i64>> for &'a Wrapping<i64>

type Output = <Wrapping<i64> as Mul<Wrapping<i64>>>::Output

impl<'a> Mul<Wrapping<i128>> for &'a Wrapping<i128>

type Output = <Wrapping<i128> as Mul<Wrapping<i128>>>::Output

impl<'a> Mul<Wrapping<isize>> for &'a Wrapping<isize>

type Output = <Wrapping<isize> as Mul<Wrapping<isize>>>::Output

impl<'a> Mul<Wrapping<u8>> for &'a Wrapping<u8>

type Output = <Wrapping<u8> as Mul<Wrapping<u8>>>::Output

impl<'a> Mul<Wrapping<u16>> for &'a Wrapping<u16>

type Output = <Wrapping<u16> as Mul<Wrapping<u16>>>::Output

impl<'a> Mul<Wrapping<u32>> for &'a Wrapping<u32>

type Output = <Wrapping<u32> as Mul<Wrapping<u32>>>::Output

impl<'a> Mul<Wrapping<u64>> for &'a Wrapping<u64>

type Output = <Wrapping<u64> as Mul<Wrapping<u64>>>::Output

impl<'a> Mul<Wrapping<u128>> for &'a Wrapping<u128>

type Output = <Wrapping<u128> as Mul<Wrapping<u128>>>::Output

impl<'a> Mul<Wrapping<usize>> for &'a Wrapping<usize>

type Output = <Wrapping<usize> as Mul<Wrapping<usize>>>::Output

impl<'a> Mul<BigInt> for &'a i8

type Output = BigInt

impl<'a> Mul<BigInt> for &'a i16

type Output = BigInt

impl<'a> Mul<BigInt> for &'a i32

type Output = BigInt

impl<'a> Mul<BigInt> for &'a i64

type Output = BigInt

impl<'a> Mul<BigInt> for &'a i128

type Output = BigInt

impl<'a> Mul<BigInt> for &'a isize

type Output = BigInt

impl<'a> Mul<BigInt> for &'a u8

type Output = BigInt

impl<'a> Mul<BigInt> for &'a u16

type Output = BigInt

impl<'a> Mul<BigInt> for &'a u32

type Output = BigInt

impl<'a> Mul<BigInt> for &'a u64

type Output = BigInt

impl<'a> Mul<BigInt> for &'a u128

type Output = BigInt

impl<'a> Mul<BigInt> for &'a usize

type Output = BigInt

impl<'a> Mul<BigInt> for &'a BigInt

type Output = BigInt

impl<'a> Mul<BigUint> for &'a u8

type Output = BigUint

impl<'a> Mul<BigUint> for &'a u16

type Output = BigUint

impl<'a> Mul<BigUint> for &'a u32

type Output = BigUint

impl<'a> Mul<BigUint> for &'a u64

type Output = BigUint

impl<'a> Mul<BigUint> for &'a u128

type Output = BigUint

impl<'a> Mul<BigUint> for &'a usize

type Output = BigUint

impl<'a> Mul<BigUint> for &'a BigUint

type Output = BigUint

impl<'a> Mul<Complex<f32>> for &'a f32

type Output = Complex<f32>

impl<'a> Mul<Complex<f64>> for &'a f64

type Output = Complex<f64>

impl<'a> Mul<Complex<i8>> for &'a i8

type Output = Complex<i8>

impl<'a> Mul<Complex<i16>> for &'a i16

type Output = Complex<i16>

impl<'a> Mul<Complex<i32>> for &'a i32

type Output = Complex<i32>

impl<'a> Mul<Complex<i64>> for &'a i64

type Output = Complex<i64>

impl<'a> Mul<Complex<i128>> for &'a i128

type Output = Complex<i128>

impl<'a> Mul<Complex<isize>> for &'a isize

type Output = Complex<isize>

impl<'a> Mul<Complex<u8>> for &'a u8

type Output = Complex<u8>

impl<'a> Mul<Complex<u16>> for &'a u16

type Output = Complex<u16>

impl<'a> Mul<Complex<u32>> for &'a u32

type Output = Complex<u32>

impl<'a> Mul<Complex<u64>> for &'a u64

type Output = Complex<u64>

impl<'a> Mul<Complex<u128>> for &'a u128

type Output = Complex<u128>

impl<'a> Mul<Complex<usize>> for &'a usize

type Output = Complex<usize>

impl<'a, 'b> Mul<&'a BigInt> for &'b i8

type Output = BigInt

impl<'a, 'b> Mul<&'a BigInt> for &'b i16

type Output = BigInt

impl<'a, 'b> Mul<&'a BigInt> for &'b i32

type Output = BigInt

impl<'a, 'b> Mul<&'a BigInt> for &'b i64

type Output = BigInt

impl<'a, 'b> Mul<&'a BigInt> for &'b i128

type Output = BigInt

impl<'a, 'b> Mul<&'a BigInt> for &'b isize

type Output = BigInt

impl<'a, 'b> Mul<&'a BigInt> for &'b u8

type Output = BigInt

impl<'a, 'b> Mul<&'a BigInt> for &'b u16

type Output = BigInt

impl<'a, 'b> Mul<&'a BigInt> for &'b u32

type Output = BigInt

impl<'a, 'b> Mul<&'a BigInt> for &'b u64

type Output = BigInt

impl<'a, 'b> Mul<&'a BigInt> for &'b u128

type Output = BigInt

impl<'a, 'b> Mul<&'a BigInt> for &'b usize

type Output = BigInt

impl<'a, 'b> Mul<&'a BigUint> for &'b u8

type Output = BigUint

impl<'a, 'b> Mul<&'a BigUint> for &'b u16

type Output = BigUint

impl<'a, 'b> Mul<&'a BigUint> for &'b u32

type Output = BigUint

impl<'a, 'b> Mul<&'a BigUint> for &'b u64

type Output = BigUint

impl<'a, 'b> Mul<&'a BigUint> for &'b u128

type Output = BigUint

impl<'a, 'b> Mul<&'a BigUint> for &'b usize

type Output = BigUint

impl<'a, 'b> Mul<&'a Complex<f32>> for &'b f32

type Output = Complex<f32>

impl<'a, 'b> Mul<&'a Complex<f64>> for &'b f64

type Output = Complex<f64>

impl<'a, 'b> Mul<&'a Complex<i8>> for &'b i8

type Output = Complex<i8>

impl<'a, 'b> Mul<&'a Complex<i16>> for &'b i16

type Output = Complex<i16>

impl<'a, 'b> Mul<&'a Complex<i32>> for &'b i32

type Output = Complex<i32>

impl<'a, 'b> Mul<&'a Complex<i64>> for &'b i64

type Output = Complex<i64>

impl<'a, 'b> Mul<&'a Complex<i128>> for &'b i128

type Output = Complex<i128>

impl<'a, 'b> Mul<&'a Complex<isize>> for &'b isize

type Output = Complex<isize>

impl<'a, 'b> Mul<&'a Complex<u8>> for &'b u8

type Output = Complex<u8>

impl<'a, 'b> Mul<&'a Complex<u16>> for &'b u16

type Output = Complex<u16>

impl<'a, 'b> Mul<&'a Complex<u32>> for &'b u32

type Output = Complex<u32>

impl<'a, 'b> Mul<&'a Complex<u64>> for &'b u64

type Output = Complex<u64>

impl<'a, 'b> Mul<&'a Complex<u128>> for &'b u128

type Output = Complex<u128>

impl<'a, 'b> Mul<&'a Complex<usize>> for &'b usize

type Output = Complex<usize>

impl<'a, 'b> Mul<&'b i8> for &'a BigInt

type Output = BigInt

impl<'a, 'b> Mul<&'b i16> for &'a BigInt

type Output = BigInt

impl<'a, 'b> Mul<&'b i32> for &'a BigInt

type Output = BigInt

impl<'a, 'b> Mul<&'b i64> for &'a BigInt

type Output = BigInt

impl<'a, 'b> Mul<&'b i128> for &'a BigInt

type Output = BigInt

impl<'a, 'b> Mul<&'b isize> for &'a BigInt

type Output = BigInt

impl<'a, 'b> Mul<&'b u8> for &'a BigInt

type Output = BigInt

impl<'a, 'b> Mul<&'b u8> for &'a BigUint

type Output = BigUint

impl<'a, 'b> Mul<&'b u16> for &'a BigInt

type Output = BigInt

impl<'a, 'b> Mul<&'b u16> for &'a BigUint

type Output = BigUint

impl<'a, 'b> Mul<&'b u32> for &'a BigInt

type Output = BigInt

impl<'a, 'b> Mul<&'b u32> for &'a BigUint

type Output = BigUint

impl<'a, 'b> Mul<&'b u64> for &'a BigInt

type Output = BigInt

impl<'a, 'b> Mul<&'b u64> for &'a BigUint

type Output = BigUint

impl<'a, 'b> Mul<&'b u128> for &'a BigInt

type Output = BigInt

impl<'a, 'b> Mul<&'b u128> for &'a BigUint

type Output = BigUint

impl<'a, 'b> Mul<&'b usize> for &'a BigInt

type Output = BigInt

impl<'a, 'b> Mul<&'b usize> for &'a BigUint

type Output = BigUint

impl<'a, 'b> Mul<&'b BigInt> for &'a BigInt

type Output = BigInt

impl<'a, 'b> Mul<&'b BigUint> for &'a BigUint

type Output = BigUint

impl<'a, 'b, T> Mul<&'a Unit<DualQuaternion<T>>> for &'b Translation<T, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<'a, 'b, T> Mul<&'b Unit<DualQuaternion<T>>> for &'a Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<'a, 'b, T> Mul<&'b Unit<DualQuaternion<T>>> for &'a Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<'a, 'b, T> Mul<&'b Unit<DualQuaternion<T>>> for &'a DualQuaternion<T>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = DualQuaternion<T>

impl<'a, 'b, T> Mul<&'b Unit<DualQuaternion<T>>> for &'a Isometry<T, Unit<Quaternion<T>>, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<'a, 'b, T> Mul<&'b Unit<Quaternion<T>>> for &'a Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<'a, 'b, T> Mul<&'b Unit<Quaternion<T>>> for &'a Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Quaternion<T>>

impl<'a, 'b, T> Mul<&'b Unit<Quaternion<T>>> for &'a Isometry<T, Unit<Quaternion<T>>, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Quaternion<T>>, 3>

impl<'a, 'b, T> Mul<&'b Unit<Quaternion<T>>> for &'a Rotation<T, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Quaternion<T>>

impl<'a, 'b, T> Mul<&'b Unit<Quaternion<T>>> for &'a Similarity<T, Unit<Quaternion<T>>, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Unit<Quaternion<T>>, 3>

impl<'a, 'b, T> Mul<&'b Unit<Quaternion<T>>> for &'a Translation<T, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Quaternion<T>>, 3>

impl<'a, 'b, T> Mul<&'b Unit<Complex<T>>> for &'a Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Complex<T>>

impl<'a, 'b, T> Mul<&'b Unit<Complex<T>>> for &'a Isometry<T, Unit<Complex<T>>, 2>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Complex<T>>, 2>

impl<'a, 'b, T> Mul<&'b Unit<Complex<T>>> for &'a Rotation<T, 2>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Complex<T>>

impl<'a, 'b, T> Mul<&'b Unit<Complex<T>>> for &'a Similarity<T, Unit<Complex<T>>, 2>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Unit<Complex<T>>, 2>

impl<'a, 'b, T> Mul<&'b Unit<Complex<T>>> for &'a Translation<T, 2>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Complex<T>>, 2>

impl<'a, 'b, T> Mul<&'b DualQuaternion<T>> for &'a Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = DualQuaternion<T>

impl<'a, 'b, T> Mul<&'b DualQuaternion<T>> for &'a DualQuaternion<T>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = DualQuaternion<T>

impl<'a, 'b, T> Mul<&'b Isometry<T, Unit<Quaternion<T>>, 3>> for &'a Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<'a, 'b, T> Mul<&'b Isometry<T, Unit<Quaternion<T>>, 3>> for &'a Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Quaternion<T>>, 3>

impl<'a, 'b, T> Mul<&'b Isometry<T, Unit<Complex<T>>, 2>> for &'a Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Complex<T>>, 2>

impl<'a, 'b, T> Mul<&'b OPoint<T, Const<2>>> for &'a Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = OPoint<T, Const<2>>

impl<'a, 'b, T> Mul<&'b OPoint<T, Const<3>>> for &'a Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = OPoint<T, Const<3>>

impl<'a, 'b, T> Mul<&'b OPoint<T, Const<3>>> for &'a Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = OPoint<T, Const<3>>

impl<'a, 'b, T> Mul<&'b Quaternion<T>> for &'a Quaternion<T>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Quaternion<T>

impl<'a, 'b, T> Mul<&'b Rotation<T, 2>> for &'a Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Complex<T>>

impl<'a, 'b, T> Mul<&'b Rotation<T, 3>> for &'a Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Quaternion<T>>

impl<'a, 'b, T> Mul<&'b Similarity<T, Unit<Quaternion<T>>, 3>> for &'a Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Unit<Quaternion<T>>, 3>

impl<'a, 'b, T> Mul<&'b Similarity<T, Unit<Complex<T>>, 2>> for &'a Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Unit<Complex<T>>, 2>

impl<'a, 'b, T> Mul<&'b Translation<T, 2>> for &'a Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Complex<T>>, 2>

impl<'a, 'b, T> Mul<&'b Translation<T, 3>> for &'a Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<'a, 'b, T> Mul<&'b Translation<T, 3>> for &'a Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Quaternion<T>>, 3>

impl<'a, 'b, T> Mul<&'b Ratio<T>> for &'a Ratio<T>where T: Clone + Integer,

type Output = Ratio<T>

impl<'a, 'b, T> Mul<&'b Complex<T>> for &'a Complex<T>where T: Clone + Num,

type Output = Complex<T>

impl<'a, 'b, T> Mul<&'a T> for &'b Complex<T>where T: Clone + Num,

type Output = Complex<T>

impl<'a, 'b, T> Mul<&'b T> for &'a Ratio<T>where T: Clone + Integer,

type Output = Ratio<T>

impl<'a, 'b, T, C> Mul<&'b Unit<Quaternion<T>>> for &'a Transform<T, C, 3>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, C: TCategoryMul<TAffine>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, 3>

impl<'a, 'b, T, C> Mul<&'b Unit<Complex<T>>> for &'a Transform<T, C, 2>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, C: TCategoryMul<TAffine>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, 2>

impl<'a, 'b, T, C> Mul<&'b Transform<T, C, 2>> for &'a Unit<Complex<T>>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, C: TCategoryMul<TAffine>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, 2>

impl<'a, 'b, T, C> Mul<&'b Transform<T, C, 3>> for &'a Unit<Quaternion<T>>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, C: TCategoryMul<TAffine>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, 3>

impl<'a, 'b, T, C, R, const D: usize> Mul<&'b Isometry<T, R, D>> for &'a Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer>>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'a, 'b, T, C, R, const D: usize> Mul<&'b Similarity<T, R, D>> for &'a Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer>>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'a, 'b, T, C, R, const D: usize> Mul<&'b Transform<T, C, D>> for &'a Isometry<T, R, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer>>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'a, 'b, T, C, R, const D: usize> Mul<&'b Transform<T, C, D>> for &'a Similarity<T, R, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer>>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'a, 'b, T, C, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategory, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>

impl<'a, 'b, T, C, const D: usize> Mul<&'b OPoint<T, Const<D>>> for &'a Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategory, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = OPoint<T, Const<D>>

impl<'a, 'b, T, C, const D: usize> Mul<&'b Rotation<T, D>> for &'a Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'a, 'b, T, C, const D: usize> Mul<&'b Transform<T, C, D>> for &'a Rotation<T, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'a, 'b, T, C, const D: usize> Mul<&'b Transform<T, C, D>> for &'a Translation<T, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'a, 'b, T, C, const D: usize> Mul<&'b Translation<T, D>> for &'a Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'a, 'b, T, CA, CB, const D: usize> Mul<&'b Transform<T, CB, D>> for &'a Transform<T, CA, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, CA: TCategoryMul<CB>, CB: TCategory, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <CA as TCategoryMul<CB>>::Representative, D>

impl<'a, 'b, T, R1, C1, R2, C2, SA, SB> Mul<&'b Matrix<T, R2, C2, SB>> for &'a Matrix<T, R1, C1, SA>where R1: Dim, C1: Dim, R2: Dim, C2: Dim, T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, SA: Storage<T, R1, C1>, SB: Storage<T, R2, C2>, DefaultAllocator: Allocator<T, R1, C2>, ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,

type Output = Matrix<T, R1, C2, <DefaultAllocator as Allocator<T, R1, C2>>::Buffer>

impl<'a, 'b, T, R1, C1, SA, const D2: usize> Mul<&'b Rotation<T, D2>> for &'a Matrix<T, R1, C1, SA>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>, DefaultAllocator: Allocator<T, R1, Const<D2>>, ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,

type Output = Matrix<T, R1, Const<D2>, <DefaultAllocator as Allocator<T, R1, Const<D2>>>::Buffer>

impl<'a, 'b, T, R2, C2, SB, const D1: usize> Mul<&'b Matrix<T, R2, C2, SB>> for &'a Rotation<T, D1>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, R2: Dim, C2: Dim, SB: Storage<T, R2, C2>, DefaultAllocator: Allocator<T, Const<D1>, C2>, ShapeConstraint: AreMultipliable<Const<D1>, Const<D1>, R2, C2>,

type Output = Matrix<T, Const<D1>, C2, <DefaultAllocator as Allocator<T, Const<D1>, C2>>::Buffer>

impl<'a, 'b, T, R, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>

impl<'a, 'b, T, R, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Similarity<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>

impl<'a, 'b, T, R, const D: usize> Mul<&'b Unit<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>>> for &'a Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Unit<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>>

impl<'a, 'b, T, R, const D: usize> Mul<&'b Isometry<T, R, D>> for &'a Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Isometry<T, R, D>

impl<'a, 'b, T, R, const D: usize> Mul<&'b Isometry<T, R, D>> for &'a Similarity<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Similarity<T, R, D>

impl<'a, 'b, T, R, const D: usize> Mul<&'b Isometry<T, R, D>> for &'a Translation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Isometry<T, R, D>

impl<'a, 'b, T, R, const D: usize> Mul<&'b OPoint<T, Const<D>>> for &'a Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = OPoint<T, Const<D>>

impl<'a, 'b, T, R, const D: usize> Mul<&'b OPoint<T, Const<D>>> for &'a Similarity<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = OPoint<T, Const<D>>

impl<'a, 'b, T, R, const D: usize> Mul<&'b Similarity<T, R, D>> for &'a Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Similarity<T, R, D>

impl<'a, 'b, T, R, const D: usize> Mul<&'b Similarity<T, R, D>> for &'a Similarity<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Similarity<T, R, D>

impl<'a, 'b, T, R, const D: usize> Mul<&'b Similarity<T, R, D>> for &'a Translation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Similarity<T, R, D>

impl<'a, 'b, T, R, const D: usize> Mul<&'b Translation<T, D>> for &'a Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Isometry<T, R, D>

impl<'a, 'b, T, R, const D: usize> Mul<&'b Translation<T, D>> for &'a Similarity<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Similarity<T, R, D>

impl<'a, 'b, T, S> Mul<&'b Matrix<T, Const<2>, Const<1>, S>> for &'a Unit<Complex<T>>where T: SimdRealField, S: Storage<T, Const<2>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Matrix<T, Const<nalgebra::::base::dimension::U2::{constant#0}>, Const<1>, ArrayStorage<T, 2, 1>>

impl<'a, 'b, T, S> Mul<&'b Unit<Matrix<T, Const<2>, Const<1>, S>>> for &'a Unit<Complex<T>>where T: SimdRealField, S: Storage<T, Const<2>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Matrix<T, Const<nalgebra::::base::dimension::U2::{constant#0}>, Const<1>, ArrayStorage<T, 2, 1>>>

impl<'a, 'b, T, S, const D: usize> Mul<&'b Unit<Matrix<T, Const<D>, Const<1>, S>>> for &'a Rotation<T, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, S: Storage<T, Const<D>, Const<1>>, ShapeConstraint: AreMultipliable<Const<D>, Const<D>, Const<D>, Const<1>>,

type Output = Unit<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>>

impl<'a, 'b, T, SA, const D2: usize, const R1: usize, const C1: usize> Mul<&'b OPoint<T, Const<D2>>> for &'a Matrix<T, Const<R1>, Const<C1>, SA>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, SA: Storage<T, Const<R1>, Const<C1>>, ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, Const<1>>,

type Output = OPoint<T, Const<R1>>

impl<'a, 'b, T, SB> Mul<&'b Matrix<T, Const<3>, Const<1>, SB>> for &'a Unit<Quaternion<T>>where T: SimdRealField, SB: Storage<T, Const<3>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, ArrayStorage<T, 3, 1>>

impl<'a, 'b, T, SB> Mul<&'b Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, SB>> for &'a Unit<DualQuaternion<T>>where T: SimdRealField, SB: Storage<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, ArrayStorage<T, 3, 1>>

impl<'a, 'b, T, SB> Mul<&'b Unit<Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, SB>>> for &'a Unit<DualQuaternion<T>>where T: SimdRealField, SB: Storage<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, ArrayStorage<T, 3, 1>>>

impl<'a, 'b, T, SB> Mul<&'b Unit<Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, SB>>> for &'a Unit<Quaternion<T>>where T: SimdRealField, SB: Storage<T, Const<3>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, ArrayStorage<T, 3, 1>>>

impl<'a, 'b, T, const D: usize> Mul<&'b Isometry<T, Rotation<T, D>, D>> for &'a Rotation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Rotation<T, D>, D>

impl<'a, 'b, T, const D: usize> Mul<&'b OPoint<T, Const<D>>> for &'a Rotation<T, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, ShapeConstraint: AreMultipliable<Const<D>, Const<D>, Const<D>, Const<1>>,

type Output = OPoint<T, Const<D>>

impl<'a, 'b, T, const D: usize> Mul<&'b OPoint<T, Const<D>>> for &'a Translation<T, D>where T: Scalar + ClosedAdd<T>, ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<Const<1>, Const<1>, Representative = Const<1>>,

type Output = OPoint<T, Const<D>>

impl<'a, 'b, T, const D: usize> Mul<&'b Rotation<T, D>> for &'a Isometry<T, Rotation<T, D>, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Rotation<T, D>, D>

impl<'a, 'b, T, const D: usize> Mul<&'b Rotation<T, D>> for &'a Rotation<T, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,

type Output = Rotation<T, D>

impl<'a, 'b, T, const D: usize> Mul<&'b Rotation<T, D>> for &'a Similarity<T, Rotation<T, D>, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Rotation<T, D>, D>

impl<'a, 'b, T, const D: usize> Mul<&'b Rotation<T, D>> for &'a Translation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Rotation<T, D>, D>

impl<'a, 'b, T, const D: usize> Mul<&'b Similarity<T, Rotation<T, D>, D>> for &'a Rotation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Rotation<T, D>, D>

impl<'a, 'b, T, const D: usize> Mul<&'b Translation<T, D>> for &'a Rotation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Rotation<T, D>, D>

impl<'a, 'b, T, const D: usize> Mul<&'b Translation<T, D>> for &'a Translation<T, D>where T: Scalar + ClosedAdd<T>, ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<Const<1>, Const<1>, Representative = Const<1>>,

type Output = Translation<T, D>

impl<'a, A, B, S, S2, D, E> Mul<&'a ArrayBase<S2, E>> for &'a ArrayBase<S, D>where A: Clone + Mul<B, Output = A>, B: Clone, S: Data<Elem = A>, S2: Data<Elem = B>, D: Dimension + DimMax<E>, E: Dimension,

Perform elementwise multiplication between references self and rhs, and return the result as a new Array.

If their shapes disagree, self and rhs is broadcast to their broadcast shape, cloning the data if needed.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<OwnedRepr<A>, <D as DimMax<E>>::Output>

impl<'a, A, B, S, S2, D, E> Mul<&'a ArrayBase<S2, E>> for ArrayBase<S, D>where A: Clone + Mul<B, Output = A>, B: Clone, S: DataOwned<Elem = A> + DataMut, S2: Data<Elem = B>, D: Dimension + DimMax<E>, E: Dimension,

Perform elementwise multiplication between self and reference rhs, and return the result.

rhs must be an Array or ArcArray.

If their shapes disagree, self is broadcast to their broadcast shape, cloning the data if needed.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, <D as DimMax<E>>::Output>

impl<'a, A, B, S, S2, D, E> Mul<ArrayBase<S2, E>> for &'a ArrayBase<S, D>where A: Clone + Mul<B, Output = B>, B: Clone, S: Data<Elem = A>, S2: DataOwned<Elem = B> + DataMut, D: Dimension, E: Dimension + DimMax<D>,

Perform elementwise multiplication between reference self and rhs, and return the result.

rhs must be an Array or ArcArray.

If their shapes disagree, self is broadcast to their broadcast shape, cloning the data if needed.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S2, <E as DimMax<D>>::Output>

impl<'a, A, S, D, B> Mul<B> for &'a ArrayBase<S, D>where A: Clone + Mul<B, Output = A>, S: Data<Elem = A>, D: Dimension, B: ScalarOperand,

Perform elementwise multiplication between the reference self and the scalar x, and return the result as a new Array.

type Output = ArrayBase<OwnedRepr<A>, D>

impl<'a, S, D> Mul<&'a ArrayBase<S, D>> for f32where S: Data<Elem = f32>, D: Dimension,

type Output = ArrayBase<OwnedRepr<f32>, D>

impl<'a, S, D> Mul<&'a ArrayBase<S, D>> for f64where S: Data<Elem = f64>, D: Dimension,

type Output = ArrayBase<OwnedRepr<f64>, D>

impl<'a, S, D> Mul<&'a ArrayBase<S, D>> for i8where S: Data<Elem = i8>, D: Dimension,

type Output = ArrayBase<OwnedRepr<i8>, D>

impl<'a, S, D> Mul<&'a ArrayBase<S, D>> for i16where S: Data<Elem = i16>, D: Dimension,

type Output = ArrayBase<OwnedRepr<i16>, D>

impl<'a, S, D> Mul<&'a ArrayBase<S, D>> for i32where S: Data<Elem = i32>, D: Dimension,

type Output = ArrayBase<OwnedRepr<i32>, D>

impl<'a, S, D> Mul<&'a ArrayBase<S, D>> for i64where S: Data<Elem = i64>, D: Dimension,

type Output = ArrayBase<OwnedRepr<i64>, D>

impl<'a, S, D> Mul<&'a ArrayBase<S, D>> for i128where S: Data<Elem = i128>, D: Dimension,

type Output = ArrayBase<OwnedRepr<i128>, D>

impl<'a, S, D> Mul<&'a ArrayBase<S, D>> for isizewhere S: Data<Elem = isize>, D: Dimension,

type Output = ArrayBase<OwnedRepr<isize>, D>

impl<'a, S, D> Mul<&'a ArrayBase<S, D>> for u8where S: Data<Elem = u8>, D: Dimension,

type Output = ArrayBase<OwnedRepr<u8>, D>

impl<'a, S, D> Mul<&'a ArrayBase<S, D>> for u16where S: Data<Elem = u16>, D: Dimension,

type Output = ArrayBase<OwnedRepr<u16>, D>

impl<'a, S, D> Mul<&'a ArrayBase<S, D>> for u32where S: Data<Elem = u32>, D: Dimension,

type Output = ArrayBase<OwnedRepr<u32>, D>

impl<'a, S, D> Mul<&'a ArrayBase<S, D>> for u64where S: Data<Elem = u64>, D: Dimension,

type Output = ArrayBase<OwnedRepr<u64>, D>

impl<'a, S, D> Mul<&'a ArrayBase<S, D>> for u128where S: Data<Elem = u128>, D: Dimension,

type Output = ArrayBase<OwnedRepr<u128>, D>

impl<'a, S, D> Mul<&'a ArrayBase<S, D>> for usizewhere S: Data<Elem = usize>, D: Dimension,

type Output = ArrayBase<OwnedRepr<usize>, D>

impl<'a, S, D> Mul<&'a ArrayBase<S, D>> for Complex<f32>where S: Data<Elem = Complex<f32>>, D: Dimension,

type Output = ArrayBase<OwnedRepr<Complex<f32>>, D>

impl<'a, S, D> Mul<&'a ArrayBase<S, D>> for Complex<f64>where S: Data<Elem = Complex<f64>>, D: Dimension,

type Output = ArrayBase<OwnedRepr<Complex<f64>>, D>

impl<'a, T> Mul<&'a Ratio<T>> for Ratio<T>where T: Clone + Integer,

type Output = Ratio<T>

impl<'a, T> Mul<&'a Complex<T>> for Complex<T>where T: Clone + Num,

type Output = Complex<T>

impl<'a, T> Mul<&'a T> for Ratio<T>where T: Clone + Integer,

type Output = Ratio<T>

impl<'a, T> Mul<&'a T> for Complex<T>where T: Clone + Num,

type Output = Complex<T>

impl<'a, T> Mul<Unit<DualQuaternion<T>>> for &'a Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<'a, T> Mul<Unit<DualQuaternion<T>>> for &'a Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<'a, T> Mul<Unit<DualQuaternion<T>>> for &'a DualQuaternion<T>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = DualQuaternion<T>

impl<'a, T> Mul<Unit<DualQuaternion<T>>> for &'a Isometry<T, Unit<Quaternion<T>>, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<'a, T> Mul<Unit<DualQuaternion<T>>> for &'a Translation<T, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<'a, T> Mul<Unit<Quaternion<T>>> for &'a Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<'a, T> Mul<Unit<Quaternion<T>>> for &'a Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Quaternion<T>>

impl<'a, T> Mul<Unit<Quaternion<T>>> for &'a Isometry<T, Unit<Quaternion<T>>, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Quaternion<T>>, 3>

impl<'a, T> Mul<Unit<Quaternion<T>>> for &'a Rotation<T, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Quaternion<T>>

impl<'a, T> Mul<Unit<Quaternion<T>>> for &'a Similarity<T, Unit<Quaternion<T>>, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Unit<Quaternion<T>>, 3>

impl<'a, T> Mul<Unit<Quaternion<T>>> for &'a Translation<T, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Quaternion<T>>, 3>

impl<'a, T> Mul<Unit<Complex<T>>> for &'a Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Complex<T>>

impl<'a, T> Mul<Unit<Complex<T>>> for &'a Isometry<T, Unit<Complex<T>>, 2>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Complex<T>>, 2>

impl<'a, T> Mul<Unit<Complex<T>>> for &'a Rotation<T, 2>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Complex<T>>

impl<'a, T> Mul<Unit<Complex<T>>> for &'a Similarity<T, Unit<Complex<T>>, 2>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Unit<Complex<T>>, 2>

impl<'a, T> Mul<Unit<Complex<T>>> for &'a Translation<T, 2>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Complex<T>>, 2>

impl<'a, T> Mul<DualQuaternion<T>> for &'a Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = DualQuaternion<T>

impl<'a, T> Mul<DualQuaternion<T>> for &'a DualQuaternion<T>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = DualQuaternion<T>

impl<'a, T> Mul<Isometry<T, Unit<Quaternion<T>>, 3>> for &'a Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<'a, T> Mul<Isometry<T, Unit<Quaternion<T>>, 3>> for &'a Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Quaternion<T>>, 3>

impl<'a, T> Mul<Isometry<T, Unit<Complex<T>>, 2>> for &'a Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Complex<T>>, 2>

impl<'a, T> Mul<OPoint<T, Const<2>>> for &'a Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = OPoint<T, Const<2>>

impl<'a, T> Mul<OPoint<T, Const<3>>> for &'a Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = OPoint<T, Const<3>>

impl<'a, T> Mul<OPoint<T, Const<3>>> for &'a Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = OPoint<T, Const<3>>

impl<'a, T> Mul<Quaternion<T>> for &'a Quaternion<T>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Quaternion<T>

impl<'a, T> Mul<Rotation<T, 2>> for &'a Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Complex<T>>

impl<'a, T> Mul<Rotation<T, 3>> for &'a Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Quaternion<T>>

impl<'a, T> Mul<Similarity<T, Unit<Quaternion<T>>, 3>> for &'a Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Unit<Quaternion<T>>, 3>

impl<'a, T> Mul<Similarity<T, Unit<Complex<T>>, 2>> for &'a Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Unit<Complex<T>>, 2>

impl<'a, T> Mul<Translation<T, 2>> for &'a Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Complex<T>>, 2>

impl<'a, T> Mul<Translation<T, 3>> for &'a Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<'a, T> Mul<Translation<T, 3>> for &'a Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Quaternion<T>>, 3>

impl<'a, T> Mul<Ratio<T>> for &'a Ratio<T>where T: Clone + Integer,

type Output = Ratio<T>

impl<'a, T> Mul<Complex<T>> for &'a Complex<T>where T: Clone + Num,

type Output = Complex<T>

impl<'a, T> Mul<T> for &'a DualQuaternion<T>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = DualQuaternion<T>

impl<'a, T> Mul<T> for &'a Quaternion<T>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Quaternion<T>

impl<'a, T> Mul<T> for &'a Ratio<T>where T: Clone + Integer,

type Output = Ratio<T>

impl<'a, T> Mul<T> for &'a Complex<T>where T: Clone + Num,

type Output = Complex<T>

impl<'a, T, C> Mul<Unit<Quaternion<T>>> for &'a Transform<T, C, 3>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, C: TCategoryMul<TAffine>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, 3>

impl<'a, T, C> Mul<Unit<Complex<T>>> for &'a Transform<T, C, 2>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, C: TCategoryMul<TAffine>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, 2>

impl<'a, T, C> Mul<Transform<T, C, 2>> for &'a Unit<Complex<T>>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, C: TCategoryMul<TAffine>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, 2>

impl<'a, T, C> Mul<Transform<T, C, 3>> for &'a Unit<Quaternion<T>>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, C: TCategoryMul<TAffine>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, 3>

impl<'a, T, C, R, const D: usize> Mul<Isometry<T, R, D>> for &'a Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer>>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'a, T, C, R, const D: usize> Mul<Similarity<T, R, D>> for &'a Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer>>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'a, T, C, R, const D: usize> Mul<Transform<T, C, D>> for &'a Isometry<T, R, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer>>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'a, T, C, R, const D: usize> Mul<Transform<T, C, D>> for &'a Similarity<T, R, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer>>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'a, T, C, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategory, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>

impl<'a, T, C, const D: usize> Mul<OPoint<T, Const<D>>> for &'a Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategory, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = OPoint<T, Const<D>>

impl<'a, T, C, const D: usize> Mul<Rotation<T, D>> for &'a Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'a, T, C, const D: usize> Mul<Transform<T, C, D>> for &'a Rotation<T, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'a, T, C, const D: usize> Mul<Transform<T, C, D>> for &'a Translation<T, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'a, T, C, const D: usize> Mul<Translation<T, D>> for &'a Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'a, T, CA, CB, const D: usize> Mul<Transform<T, CB, D>> for &'a Transform<T, CA, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, CA: TCategoryMul<CB>, CB: TCategory, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <CA as TCategoryMul<CB>>::Representative, D>

impl<'a, T, D> Mul<T> for &'a OPoint<T, D>where T: Scalar + ClosedMul<T>, D: DimName, DefaultAllocator: Allocator<T, D, Const<1>>,

type Output = OPoint<T, D>

impl<'a, T, R1, C1, R2, C2, SA, SB> Mul<Matrix<T, R2, C2, SB>> for &'a Matrix<T, R1, C1, SA>where R1: Dim, C1: Dim, R2: Dim, C2: Dim, T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, SB: Storage<T, R2, C2>, SA: Storage<T, R1, C1>, DefaultAllocator: Allocator<T, R1, C2>, ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,

type Output = Matrix<T, R1, C2, <DefaultAllocator as Allocator<T, R1, C2>>::Buffer>

impl<'a, T, R1, C1, SA, const D2: usize> Mul<Rotation<T, D2>> for &'a Matrix<T, R1, C1, SA>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>, DefaultAllocator: Allocator<T, R1, Const<D2>>, ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,

type Output = Matrix<T, R1, Const<D2>, <DefaultAllocator as Allocator<T, R1, Const<D2>>>::Buffer>

impl<'a, T, R2, C2, SB, const D1: usize> Mul<Matrix<T, R2, C2, SB>> for &'a Rotation<T, D1>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, R2: Dim, C2: Dim, SB: Storage<T, R2, C2>, DefaultAllocator: Allocator<T, Const<D1>, C2>, ShapeConstraint: AreMultipliable<Const<D1>, Const<D1>, R2, C2>,

type Output = Matrix<T, Const<D1>, C2, <DefaultAllocator as Allocator<T, Const<D1>, C2>>::Buffer>

impl<'a, T, R, C, S> Mul<T> for &'a Matrix<T, R, C, S>where R: Dim, C: Dim, T: Scalar + ClosedMul<T>, S: Storage<T, R, C>, DefaultAllocator: Allocator<T, R, C>,

type Output = Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>

impl<'a, T, R, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>

impl<'a, T, R, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Similarity<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>

impl<'a, T, R, const D: usize> Mul<Unit<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>>> for &'a Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Unit<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>>

impl<'a, T, R, const D: usize> Mul<Isometry<T, R, D>> for &'a Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Isometry<T, R, D>

impl<'a, T, R, const D: usize> Mul<Isometry<T, R, D>> for &'a Similarity<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Similarity<T, R, D>

impl<'a, T, R, const D: usize> Mul<Isometry<T, R, D>> for &'a Translation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Isometry<T, R, D>

impl<'a, T, R, const D: usize> Mul<OPoint<T, Const<D>>> for &'a Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = OPoint<T, Const<D>>

impl<'a, T, R, const D: usize> Mul<OPoint<T, Const<D>>> for &'a Similarity<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = OPoint<T, Const<D>>

impl<'a, T, R, const D: usize> Mul<Similarity<T, R, D>> for &'a Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Similarity<T, R, D>

impl<'a, T, R, const D: usize> Mul<Similarity<T, R, D>> for &'a Similarity<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Similarity<T, R, D>

impl<'a, T, R, const D: usize> Mul<Similarity<T, R, D>> for &'a Translation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Similarity<T, R, D>

impl<'a, T, R, const D: usize> Mul<Translation<T, D>> for &'a Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Isometry<T, R, D>

impl<'a, T, R, const D: usize> Mul<Translation<T, D>> for &'a Similarity<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Similarity<T, R, D>

impl<'a, T, S> Mul<Matrix<T, Const<2>, Const<1>, S>> for &'a Unit<Complex<T>>where T: SimdRealField, S: Storage<T, Const<2>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Matrix<T, Const<nalgebra::::base::dimension::U2::{constant#0}>, Const<1>, ArrayStorage<T, 2, 1>>

impl<'a, T, S> Mul<Unit<Matrix<T, Const<2>, Const<1>, S>>> for &'a Unit<Complex<T>>where T: SimdRealField, S: Storage<T, Const<2>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Matrix<T, Const<nalgebra::::base::dimension::U2::{constant#0}>, Const<1>, ArrayStorage<T, 2, 1>>>

impl<'a, T, S, const D: usize> Mul<Unit<Matrix<T, Const<D>, Const<1>, S>>> for &'a Rotation<T, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, S: Storage<T, Const<D>, Const<1>>, ShapeConstraint: AreMultipliable<Const<D>, Const<D>, Const<D>, Const<1>>,

type Output = Unit<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>>

impl<'a, T, SA, const D2: usize, const R1: usize, const C1: usize> Mul<OPoint<T, Const<D2>>> for &'a Matrix<T, Const<R1>, Const<C1>, SA>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, SA: Storage<T, Const<R1>, Const<C1>>, ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, Const<1>>,

type Output = OPoint<T, Const<R1>>

impl<'a, T, SB> Mul<Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, SB>> for &'a Unit<DualQuaternion<T>>where T: SimdRealField, SB: Storage<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, ArrayStorage<T, 3, 1>>

impl<'a, T, SB> Mul<Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, SB>> for &'a Unit<Quaternion<T>>where T: SimdRealField, SB: Storage<T, Const<3>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, ArrayStorage<T, 3, 1>>

impl<'a, T, SB> Mul<Unit<Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, SB>>> for &'a Unit<DualQuaternion<T>>where T: SimdRealField, SB: Storage<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, ArrayStorage<T, 3, 1>>>

impl<'a, T, SB> Mul<Unit<Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, SB>>> for &'a Unit<Quaternion<T>>where T: SimdRealField, SB: Storage<T, Const<3>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, ArrayStorage<T, 3, 1>>>

impl<'a, T, const D: usize> Mul<Isometry<T, Rotation<T, D>, D>> for &'a Rotation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Rotation<T, D>, D>

impl<'a, T, const D: usize> Mul<OPoint<T, Const<D>>> for &'a Rotation<T, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, ShapeConstraint: AreMultipliable<Const<D>, Const<D>, Const<D>, Const<1>>,

type Output = OPoint<T, Const<D>>

impl<'a, T, const D: usize> Mul<OPoint<T, Const<D>>> for &'a Translation<T, D>where T: Scalar + ClosedAdd<T>, ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<Const<1>, Const<1>, Representative = Const<1>>,

type Output = OPoint<T, Const<D>>

impl<'a, T, const D: usize> Mul<Rotation<T, D>> for &'a Isometry<T, Rotation<T, D>, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Rotation<T, D>, D>

impl<'a, T, const D: usize> Mul<Rotation<T, D>> for &'a Rotation<T, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,

type Output = Rotation<T, D>

impl<'a, T, const D: usize> Mul<Rotation<T, D>> for &'a Similarity<T, Rotation<T, D>, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Rotation<T, D>, D>

impl<'a, T, const D: usize> Mul<Rotation<T, D>> for &'a Translation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Rotation<T, D>, D>

impl<'a, T, const D: usize> Mul<Similarity<T, Rotation<T, D>, D>> for &'a Rotation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Rotation<T, D>, D>

impl<'a, T, const D: usize> Mul<Translation<T, D>> for &'a Rotation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Rotation<T, D>, D>

impl<'a, T, const D: usize> Mul<Translation<T, D>> for &'a Translation<T, D>where T: Scalar + ClosedAdd<T>, ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<Const<1>, Const<1>, Representative = Const<1>>,

type Output = Translation<T, D>

impl<'b> Mul<&'b DualQuaternion<f32>> for f32

type Output = DualQuaternion<f32>

impl<'b> Mul<&'b DualQuaternion<f64>> for f64

type Output = DualQuaternion<f64>

impl<'b> Mul<&'b Quaternion<f32>> for f32

type Output = Quaternion<f32>

impl<'b> Mul<&'b Quaternion<f64>> for f64

type Output = Quaternion<f64>

impl<'b> Mul<&'b BigInt> for BigInt

type Output = BigInt

impl<'b> Mul<&'b BigUint> for BigUint

type Output = BigUint

impl<'b, D> Mul<&'b OPoint<f32, D>> for f32where D: DimName, DefaultAllocator: Allocator<f32, D, Const<1>>,

type Output = OPoint<f32, D>

impl<'b, D> Mul<&'b OPoint<f64, D>> for f64where D: DimName, DefaultAllocator: Allocator<f64, D, Const<1>>,

type Output = OPoint<f64, D>

impl<'b, D> Mul<&'b OPoint<i8, D>> for i8where D: DimName, DefaultAllocator: Allocator<i8, D, Const<1>>,

type Output = OPoint<i8, D>

impl<'b, D> Mul<&'b OPoint<i16, D>> for i16where D: DimName, DefaultAllocator: Allocator<i16, D, Const<1>>,

type Output = OPoint<i16, D>

impl<'b, D> Mul<&'b OPoint<i32, D>> for i32where D: DimName, DefaultAllocator: Allocator<i32, D, Const<1>>,

type Output = OPoint<i32, D>

impl<'b, D> Mul<&'b OPoint<i64, D>> for i64where D: DimName, DefaultAllocator: Allocator<i64, D, Const<1>>,

type Output = OPoint<i64, D>

impl<'b, D> Mul<&'b OPoint<isize, D>> for isizewhere D: DimName, DefaultAllocator: Allocator<isize, D, Const<1>>,

type Output = OPoint<isize, D>

impl<'b, D> Mul<&'b OPoint<u8, D>> for u8where D: DimName, DefaultAllocator: Allocator<u8, D, Const<1>>,

type Output = OPoint<u8, D>

impl<'b, D> Mul<&'b OPoint<u16, D>> for u16where D: DimName, DefaultAllocator: Allocator<u16, D, Const<1>>,

type Output = OPoint<u16, D>

impl<'b, D> Mul<&'b OPoint<u32, D>> for u32where D: DimName, DefaultAllocator: Allocator<u32, D, Const<1>>,

type Output = OPoint<u32, D>

impl<'b, D> Mul<&'b OPoint<u64, D>> for u64where D: DimName, DefaultAllocator: Allocator<u64, D, Const<1>>,

type Output = OPoint<u64, D>

impl<'b, D> Mul<&'b OPoint<usize, D>> for usizewhere D: DimName, DefaultAllocator: Allocator<usize, D, Const<1>>,

type Output = OPoint<usize, D>

impl<'b, R, C, S> Mul<&'b Matrix<f32, R, C, S>> for f32where R: Dim, C: Dim, S: Storage<f32, R, C>, DefaultAllocator: Allocator<f32, R, C>,

type Output = Matrix<f32, R, C, <DefaultAllocator as Allocator<f32, R, C>>::Buffer>

impl<'b, R, C, S> Mul<&'b Matrix<f64, R, C, S>> for f64where R: Dim, C: Dim, S: Storage<f64, R, C>, DefaultAllocator: Allocator<f64, R, C>,

type Output = Matrix<f64, R, C, <DefaultAllocator as Allocator<f64, R, C>>::Buffer>

impl<'b, R, C, S> Mul<&'b Matrix<i8, R, C, S>> for i8where R: Dim, C: Dim, S: Storage<i8, R, C>, DefaultAllocator: Allocator<i8, R, C>,

type Output = Matrix<i8, R, C, <DefaultAllocator as Allocator<i8, R, C>>::Buffer>

impl<'b, R, C, S> Mul<&'b Matrix<i16, R, C, S>> for i16where R: Dim, C: Dim, S: Storage<i16, R, C>, DefaultAllocator: Allocator<i16, R, C>,

type Output = Matrix<i16, R, C, <DefaultAllocator as Allocator<i16, R, C>>::Buffer>

impl<'b, R, C, S> Mul<&'b Matrix<i32, R, C, S>> for i32where R: Dim, C: Dim, S: Storage<i32, R, C>, DefaultAllocator: Allocator<i32, R, C>,

type Output = Matrix<i32, R, C, <DefaultAllocator as Allocator<i32, R, C>>::Buffer>

impl<'b, R, C, S> Mul<&'b Matrix<i64, R, C, S>> for i64where R: Dim, C: Dim, S: Storage<i64, R, C>, DefaultAllocator: Allocator<i64, R, C>,

type Output = Matrix<i64, R, C, <DefaultAllocator as Allocator<i64, R, C>>::Buffer>

impl<'b, R, C, S> Mul<&'b Matrix<isize, R, C, S>> for isizewhere R: Dim, C: Dim, S: Storage<isize, R, C>, DefaultAllocator: Allocator<isize, R, C>,

type Output = Matrix<isize, R, C, <DefaultAllocator as Allocator<isize, R, C>>::Buffer>

impl<'b, R, C, S> Mul<&'b Matrix<u8, R, C, S>> for u8where R: Dim, C: Dim, S: Storage<u8, R, C>, DefaultAllocator: Allocator<u8, R, C>,

type Output = Matrix<u8, R, C, <DefaultAllocator as Allocator<u8, R, C>>::Buffer>

impl<'b, R, C, S> Mul<&'b Matrix<u16, R, C, S>> for u16where R: Dim, C: Dim, S: Storage<u16, R, C>, DefaultAllocator: Allocator<u16, R, C>,

type Output = Matrix<u16, R, C, <DefaultAllocator as Allocator<u16, R, C>>::Buffer>

impl<'b, R, C, S> Mul<&'b Matrix<u32, R, C, S>> for u32where R: Dim, C: Dim, S: Storage<u32, R, C>, DefaultAllocator: Allocator<u32, R, C>,

type Output = Matrix<u32, R, C, <DefaultAllocator as Allocator<u32, R, C>>::Buffer>

impl<'b, R, C, S> Mul<&'b Matrix<u64, R, C, S>> for u64where R: Dim, C: Dim, S: Storage<u64, R, C>, DefaultAllocator: Allocator<u64, R, C>,

type Output = Matrix<u64, R, C, <DefaultAllocator as Allocator<u64, R, C>>::Buffer>

impl<'b, R, C, S> Mul<&'b Matrix<usize, R, C, S>> for usizewhere R: Dim, C: Dim, S: Storage<usize, R, C>, DefaultAllocator: Allocator<usize, R, C>,

type Output = Matrix<usize, R, C, <DefaultAllocator as Allocator<usize, R, C>>::Buffer>

impl<'b, T> Mul<&'b Unit<DualQuaternion<T>>> for Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<'b, T> Mul<&'b Unit<DualQuaternion<T>>> for Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<'b, T> Mul<&'b Unit<DualQuaternion<T>>> for DualQuaternion<T>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = DualQuaternion<T>

impl<'b, T> Mul<&'b Unit<DualQuaternion<T>>> for Isometry<T, Unit<Quaternion<T>>, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<'b, T> Mul<&'b Unit<DualQuaternion<T>>> for Translation<T, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<'b, T> Mul<&'b Unit<Quaternion<T>>> for Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<'b, T> Mul<&'b Unit<Quaternion<T>>> for Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Quaternion<T>>

impl<'b, T> Mul<&'b Unit<Quaternion<T>>> for Isometry<T, Unit<Quaternion<T>>, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Quaternion<T>>, 3>

impl<'b, T> Mul<&'b Unit<Quaternion<T>>> for Rotation<T, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Quaternion<T>>

impl<'b, T> Mul<&'b Unit<Quaternion<T>>> for Similarity<T, Unit<Quaternion<T>>, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Unit<Quaternion<T>>, 3>

impl<'b, T> Mul<&'b Unit<Quaternion<T>>> for Translation<T, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Quaternion<T>>, 3>

impl<'b, T> Mul<&'b Unit<Complex<T>>> for Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Complex<T>>

impl<'b, T> Mul<&'b Unit<Complex<T>>> for Isometry<T, Unit<Complex<T>>, 2>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Complex<T>>, 2>

impl<'b, T> Mul<&'b Unit<Complex<T>>> for Rotation<T, 2>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Complex<T>>

impl<'b, T> Mul<&'b Unit<Complex<T>>> for Similarity<T, Unit<Complex<T>>, 2>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Unit<Complex<T>>, 2>

impl<'b, T> Mul<&'b Unit<Complex<T>>> for Translation<T, 2>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Complex<T>>, 2>

impl<'b, T> Mul<&'b DualQuaternion<T>> for Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = DualQuaternion<T>

impl<'b, T> Mul<&'b DualQuaternion<T>> for DualQuaternion<T>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = DualQuaternion<T>

impl<'b, T> Mul<&'b Isometry<T, Unit<Quaternion<T>>, 3>> for Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<'b, T> Mul<&'b Isometry<T, Unit<Quaternion<T>>, 3>> for Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Quaternion<T>>, 3>

impl<'b, T> Mul<&'b Isometry<T, Unit<Complex<T>>, 2>> for Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Complex<T>>, 2>

impl<'b, T> Mul<&'b OPoint<T, Const<2>>> for Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = OPoint<T, Const<2>>

impl<'b, T> Mul<&'b OPoint<T, Const<3>>> for Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = OPoint<T, Const<3>>

impl<'b, T> Mul<&'b OPoint<T, Const<3>>> for Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = OPoint<T, Const<3>>

impl<'b, T> Mul<&'b Quaternion<T>> for Quaternion<T>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Quaternion<T>

impl<'b, T> Mul<&'b Rotation<T, 2>> for Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Complex<T>>

impl<'b, T> Mul<&'b Rotation<T, 3>> for Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Quaternion<T>>

impl<'b, T> Mul<&'b Similarity<T, Unit<Quaternion<T>>, 3>> for Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Unit<Quaternion<T>>, 3>

impl<'b, T> Mul<&'b Similarity<T, Unit<Complex<T>>, 2>> for Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Unit<Complex<T>>, 2>

impl<'b, T> Mul<&'b Translation<T, 2>> for Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Complex<T>>, 2>

impl<'b, T> Mul<&'b Translation<T, 3>> for Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<'b, T> Mul<&'b Translation<T, 3>> for Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Quaternion<T>>, 3>

impl<'b, T, C> Mul<&'b Unit<Quaternion<T>>> for Transform<T, C, 3>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, C: TCategoryMul<TAffine>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, 3>

impl<'b, T, C> Mul<&'b Unit<Complex<T>>> for Transform<T, C, 2>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, C: TCategoryMul<TAffine>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, 2>

impl<'b, T, C> Mul<&'b Transform<T, C, 2>> for Unit<Complex<T>>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, C: TCategoryMul<TAffine>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, 2>

impl<'b, T, C> Mul<&'b Transform<T, C, 3>> for Unit<Quaternion<T>>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, C: TCategoryMul<TAffine>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, 3>

impl<'b, T, C, R, const D: usize> Mul<&'b Isometry<T, R, D>> for Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer>>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'b, T, C, R, const D: usize> Mul<&'b Similarity<T, R, D>> for Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer>>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'b, T, C, R, const D: usize> Mul<&'b Transform<T, C, D>> for Isometry<T, R, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer>>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'b, T, C, R, const D: usize> Mul<&'b Transform<T, C, D>> for Similarity<T, R, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer>>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'b, T, C, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategory, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>

impl<'b, T, C, const D: usize> Mul<&'b OPoint<T, Const<D>>> for Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategory, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = OPoint<T, Const<D>>

impl<'b, T, C, const D: usize> Mul<&'b Rotation<T, D>> for Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'b, T, C, const D: usize> Mul<&'b Transform<T, C, D>> for Rotation<T, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'b, T, C, const D: usize> Mul<&'b Transform<T, C, D>> for Translation<T, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'b, T, C, const D: usize> Mul<&'b Translation<T, D>> for Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<'b, T, CA, CB, const D: usize> Mul<&'b Transform<T, CB, D>> for Transform<T, CA, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, CA: TCategoryMul<CB>, CB: TCategory, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <CA as TCategoryMul<CB>>::Representative, D>

impl<'b, T, R1, C1, R2, C2, SA, SB> Mul<&'b Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA>where R1: Dim, C1: Dim, R2: Dim, C2: Dim, T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, SB: Storage<T, R2, C2>, SA: Storage<T, R1, C1>, DefaultAllocator: Allocator<T, R1, C2>, ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,

type Output = Matrix<T, R1, C2, <DefaultAllocator as Allocator<T, R1, C2>>::Buffer>

impl<'b, T, R1, C1, SA, const D2: usize> Mul<&'b Rotation<T, D2>> for Matrix<T, R1, C1, SA>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>, DefaultAllocator: Allocator<T, R1, Const<D2>>, ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,

type Output = Matrix<T, R1, Const<D2>, <DefaultAllocator as Allocator<T, R1, Const<D2>>>::Buffer>

impl<'b, T, R2, C2, SB, const D1: usize> Mul<&'b Matrix<T, R2, C2, SB>> for Rotation<T, D1>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, R2: Dim, C2: Dim, SB: Storage<T, R2, C2>, DefaultAllocator: Allocator<T, Const<D1>, C2>, ShapeConstraint: AreMultipliable<Const<D1>, Const<D1>, R2, C2>,

type Output = Matrix<T, Const<D1>, C2, <DefaultAllocator as Allocator<T, Const<D1>, C2>>::Buffer>

impl<'b, T, R, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>

impl<'b, T, R, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Similarity<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>

impl<'b, T, R, const D: usize> Mul<&'b Unit<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>>> for Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Unit<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>>

impl<'b, T, R, const D: usize> Mul<&'b Isometry<T, R, D>> for Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Isometry<T, R, D>

impl<'b, T, R, const D: usize> Mul<&'b Isometry<T, R, D>> for Similarity<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Similarity<T, R, D>

impl<'b, T, R, const D: usize> Mul<&'b Isometry<T, R, D>> for Translation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Isometry<T, R, D>

impl<'b, T, R, const D: usize> Mul<&'b OPoint<T, Const<D>>> for Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = OPoint<T, Const<D>>

impl<'b, T, R, const D: usize> Mul<&'b OPoint<T, Const<D>>> for Similarity<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = OPoint<T, Const<D>>

impl<'b, T, R, const D: usize> Mul<&'b Similarity<T, R, D>> for Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Similarity<T, R, D>

impl<'b, T, R, const D: usize> Mul<&'b Similarity<T, R, D>> for Similarity<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Similarity<T, R, D>

impl<'b, T, R, const D: usize> Mul<&'b Similarity<T, R, D>> for Translation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Similarity<T, R, D>

impl<'b, T, R, const D: usize> Mul<&'b Translation<T, D>> for Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Isometry<T, R, D>

impl<'b, T, R, const D: usize> Mul<&'b Translation<T, D>> for Similarity<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Similarity<T, R, D>

impl<'b, T, S> Mul<&'b Matrix<T, Const<2>, Const<1>, S>> for Unit<Complex<T>>where T: SimdRealField, S: Storage<T, Const<2>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Matrix<T, Const<nalgebra::::base::dimension::U2::{constant#0}>, Const<1>, ArrayStorage<T, 2, 1>>

impl<'b, T, S> Mul<&'b Unit<Matrix<T, Const<2>, Const<1>, S>>> for Unit<Complex<T>>where T: SimdRealField, S: Storage<T, Const<2>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Matrix<T, Const<nalgebra::::base::dimension::U2::{constant#0}>, Const<1>, ArrayStorage<T, 2, 1>>>

impl<'b, T, S, const D: usize> Mul<&'b Unit<Matrix<T, Const<D>, Const<1>, S>>> for Rotation<T, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, S: Storage<T, Const<D>, Const<1>>, ShapeConstraint: AreMultipliable<Const<D>, Const<D>, Const<D>, Const<1>>,

type Output = Unit<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>>

impl<'b, T, SA, const D2: usize, const R1: usize, const C1: usize> Mul<&'b OPoint<T, Const<D2>>> for Matrix<T, Const<R1>, Const<C1>, SA>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, SA: Storage<T, Const<R1>, Const<C1>>, ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, Const<1>>,

type Output = OPoint<T, Const<R1>>

impl<'b, T, SB> Mul<&'b Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, SB>> for Unit<DualQuaternion<T>>where T: SimdRealField, SB: Storage<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, ArrayStorage<T, 3, 1>>

impl<'b, T, SB> Mul<&'b Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, SB>> for Unit<Quaternion<T>>where T: SimdRealField, SB: Storage<T, Const<3>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, ArrayStorage<T, 3, 1>>

impl<'b, T, SB> Mul<&'b Unit<Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, SB>>> for Unit<DualQuaternion<T>>where T: SimdRealField, SB: Storage<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, ArrayStorage<T, 3, 1>>>

impl<'b, T, SB> Mul<&'b Unit<Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, SB>>> for Unit<Quaternion<T>>where T: SimdRealField, SB: Storage<T, Const<3>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, ArrayStorage<T, 3, 1>>>

impl<'b, T, const D: usize> Mul<&'b Isometry<T, Rotation<T, D>, D>> for Rotation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Rotation<T, D>, D>

impl<'b, T, const D: usize> Mul<&'b OPoint<T, Const<D>>> for Rotation<T, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, ShapeConstraint: AreMultipliable<Const<D>, Const<D>, Const<D>, Const<1>>,

type Output = OPoint<T, Const<D>>

impl<'b, T, const D: usize> Mul<&'b OPoint<T, Const<D>>> for Translation<T, D>where T: Scalar + ClosedAdd<T>, ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<Const<1>, Const<1>, Representative = Const<1>>,

type Output = OPoint<T, Const<D>>

impl<'b, T, const D: usize> Mul<&'b Rotation<T, D>> for Isometry<T, Rotation<T, D>, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Rotation<T, D>, D>

impl<'b, T, const D: usize> Mul<&'b Rotation<T, D>> for Rotation<T, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,

type Output = Rotation<T, D>

impl<'b, T, const D: usize> Mul<&'b Rotation<T, D>> for Similarity<T, Rotation<T, D>, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Rotation<T, D>, D>

impl<'b, T, const D: usize> Mul<&'b Rotation<T, D>> for Translation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Rotation<T, D>, D>

impl<'b, T, const D: usize> Mul<&'b Similarity<T, Rotation<T, D>, D>> for Rotation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Rotation<T, D>, D>

impl<'b, T, const D: usize> Mul<&'b Translation<T, D>> for Rotation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Rotation<T, D>, D>

impl<'b, T, const D: usize> Mul<&'b Translation<T, D>> for Translation<T, D>where T: Scalar + ClosedAdd<T>, ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<Const<1>, Const<1>, Representative = Const<1>>,

type Output = Translation<T, D>

impl<'lhs, 'rhs, T, const LANES: usize> Mul<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where T: SimdElement, Simd<T, LANES>: Mul<Simd<T, LANES>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

impl<'py> Mul<&'py PyComplex> for &'py PyComplex

type Output = &'py PyComplex

impl<A, B, S, S2, D, E> Mul<ArrayBase<S2, E>> for ArrayBase<S, D>where A: Clone + Mul<B, Output = A>, B: Clone, S: DataOwned<Elem = A> + DataMut, S2: Data<Elem = B>, D: Dimension + DimMax<E>, E: Dimension,

Perform elementwise multiplication between self and rhs, and return the result.

self must be an Array or ArcArray.

If their shapes disagree, self is broadcast to their broadcast shape.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, <D as DimMax<E>>::Output>

impl<A, S, D, B> Mul<B> for ArrayBase<S, D>where A: Clone + Mul<B, Output = A>, S: DataOwned<Elem = A> + DataMut, D: Dimension, B: ScalarOperand,

Perform elementwise multiplication between self and the scalar x, and return the result (based on self).

self must be an Array or ArcArray.

type Output = ArrayBase<S, D>

impl<D> Mul<OPoint<f32, D>> for f32where D: DimName, DefaultAllocator: Allocator<f32, D, Const<1>>,

type Output = OPoint<f32, D>

impl<D> Mul<OPoint<f64, D>> for f64where D: DimName, DefaultAllocator: Allocator<f64, D, Const<1>>,

type Output = OPoint<f64, D>

impl<D> Mul<OPoint<i8, D>> for i8where D: DimName, DefaultAllocator: Allocator<i8, D, Const<1>>,

type Output = OPoint<i8, D>

impl<D> Mul<OPoint<i16, D>> for i16where D: DimName, DefaultAllocator: Allocator<i16, D, Const<1>>,

type Output = OPoint<i16, D>

impl<D> Mul<OPoint<i32, D>> for i32where D: DimName, DefaultAllocator: Allocator<i32, D, Const<1>>,

type Output = OPoint<i32, D>

impl<D> Mul<OPoint<i64, D>> for i64where D: DimName, DefaultAllocator: Allocator<i64, D, Const<1>>,

type Output = OPoint<i64, D>

impl<D> Mul<OPoint<isize, D>> for isizewhere D: DimName, DefaultAllocator: Allocator<isize, D, Const<1>>,

type Output = OPoint<isize, D>

impl<D> Mul<OPoint<u8, D>> for u8where D: DimName, DefaultAllocator: Allocator<u8, D, Const<1>>,

type Output = OPoint<u8, D>

impl<D> Mul<OPoint<u16, D>> for u16where D: DimName, DefaultAllocator: Allocator<u16, D, Const<1>>,

type Output = OPoint<u16, D>

impl<D> Mul<OPoint<u32, D>> for u32where D: DimName, DefaultAllocator: Allocator<u32, D, Const<1>>,

type Output = OPoint<u32, D>

impl<D> Mul<OPoint<u64, D>> for u64where D: DimName, DefaultAllocator: Allocator<u64, D, Const<1>>,

type Output = OPoint<u64, D>

impl<D> Mul<OPoint<usize, D>> for usizewhere D: DimName, DefaultAllocator: Allocator<usize, D, Const<1>>,

type Output = OPoint<usize, D>

impl<I> Mul<usize> for Dim<I>where Dim<I>: Dimension,

type Output = Dim<I>

impl<I> Mul<Dim<I>> for Dim<I>where Dim<I>: Dimension,

type Output = Dim<I>

impl<I> Mul<I> for Z0where I: Integer,

Z0 * I = Z0

type Output = Z0

impl<R, C, S> Mul<Matrix<f32, R, C, S>> for f32where R: Dim, C: Dim, S: Storage<f32, R, C>, DefaultAllocator: Allocator<f32, R, C>,

type Output = Matrix<f32, R, C, <DefaultAllocator as Allocator<f32, R, C>>::Buffer>

impl<R, C, S> Mul<Matrix<f64, R, C, S>> for f64where R: Dim, C: Dim, S: Storage<f64, R, C>, DefaultAllocator: Allocator<f64, R, C>,

type Output = Matrix<f64, R, C, <DefaultAllocator as Allocator<f64, R, C>>::Buffer>

impl<R, C, S> Mul<Matrix<i8, R, C, S>> for i8where R: Dim, C: Dim, S: Storage<i8, R, C>, DefaultAllocator: Allocator<i8, R, C>,

type Output = Matrix<i8, R, C, <DefaultAllocator as Allocator<i8, R, C>>::Buffer>

impl<R, C, S> Mul<Matrix<i16, R, C, S>> for i16where R: Dim, C: Dim, S: Storage<i16, R, C>, DefaultAllocator: Allocator<i16, R, C>,

type Output = Matrix<i16, R, C, <DefaultAllocator as Allocator<i16, R, C>>::Buffer>

impl<R, C, S> Mul<Matrix<i32, R, C, S>> for i32where R: Dim, C: Dim, S: Storage<i32, R, C>, DefaultAllocator: Allocator<i32, R, C>,

type Output = Matrix<i32, R, C, <DefaultAllocator as Allocator<i32, R, C>>::Buffer>

impl<R, C, S> Mul<Matrix<i64, R, C, S>> for i64where R: Dim, C: Dim, S: Storage<i64, R, C>, DefaultAllocator: Allocator<i64, R, C>,

type Output = Matrix<i64, R, C, <DefaultAllocator as Allocator<i64, R, C>>::Buffer>

impl<R, C, S> Mul<Matrix<isize, R, C, S>> for isizewhere R: Dim, C: Dim, S: Storage<isize, R, C>, DefaultAllocator: Allocator<isize, R, C>,

type Output = Matrix<isize, R, C, <DefaultAllocator as Allocator<isize, R, C>>::Buffer>

impl<R, C, S> Mul<Matrix<u8, R, C, S>> for u8where R: Dim, C: Dim, S: Storage<u8, R, C>, DefaultAllocator: Allocator<u8, R, C>,

type Output = Matrix<u8, R, C, <DefaultAllocator as Allocator<u8, R, C>>::Buffer>

impl<R, C, S> Mul<Matrix<u16, R, C, S>> for u16where R: Dim, C: Dim, S: Storage<u16, R, C>, DefaultAllocator: Allocator<u16, R, C>,

type Output = Matrix<u16, R, C, <DefaultAllocator as Allocator<u16, R, C>>::Buffer>

impl<R, C, S> Mul<Matrix<u32, R, C, S>> for u32where R: Dim, C: Dim, S: Storage<u32, R, C>, DefaultAllocator: Allocator<u32, R, C>,

type Output = Matrix<u32, R, C, <DefaultAllocator as Allocator<u32, R, C>>::Buffer>

impl<R, C, S> Mul<Matrix<u64, R, C, S>> for u64where R: Dim, C: Dim, S: Storage<u64, R, C>, DefaultAllocator: Allocator<u64, R, C>,

type Output = Matrix<u64, R, C, <DefaultAllocator as Allocator<u64, R, C>>::Buffer>

impl<R, C, S> Mul<Matrix<usize, R, C, S>> for usizewhere R: Dim, C: Dim, S: Storage<usize, R, C>, DefaultAllocator: Allocator<usize, R, C>,

type Output = Matrix<usize, R, C, <DefaultAllocator as Allocator<usize, R, C>>::Buffer>

impl<Rhs> Mul<Rhs> for ATerm

type Output = ATerm

impl<Rhs, T, const N: usize> Mul<Rhs> for VecN<T, N>where Rhs: Num + Copy, T: Mul<Rhs, Output = T> + Copy,

type Output = VecN<T, N>

impl<S, D> Mul<ArrayBase<S, D>> for f32where S: DataOwned<Elem = f32> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> Mul<ArrayBase<S, D>> for f64where S: DataOwned<Elem = f64> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> Mul<ArrayBase<S, D>> for i8where S: DataOwned<Elem = i8> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> Mul<ArrayBase<S, D>> for i16where S: DataOwned<Elem = i16> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> Mul<ArrayBase<S, D>> for i32where S: DataOwned<Elem = i32> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> Mul<ArrayBase<S, D>> for i64where S: DataOwned<Elem = i64> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> Mul<ArrayBase<S, D>> for i128where S: DataOwned<Elem = i128> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> Mul<ArrayBase<S, D>> for isizewhere S: DataOwned<Elem = isize> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> Mul<ArrayBase<S, D>> for u8where S: DataOwned<Elem = u8> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> Mul<ArrayBase<S, D>> for u16where S: DataOwned<Elem = u16> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> Mul<ArrayBase<S, D>> for u32where S: DataOwned<Elem = u32> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> Mul<ArrayBase<S, D>> for u64where S: DataOwned<Elem = u64> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> Mul<ArrayBase<S, D>> for u128where S: DataOwned<Elem = u128> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> Mul<ArrayBase<S, D>> for usizewhere S: DataOwned<Elem = usize> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> Mul<ArrayBase<S, D>> for Complex<f32>where S: DataOwned<Elem = Complex<f32>> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> Mul<ArrayBase<S, D>> for Complex<f64>where S: DataOwned<Elem = Complex<f64>> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<T> Mul<VecN<T, 4>> for VecN<T, 4>where T: Sub<T, Output = T> + Mul<T, Output = T> + Add<T, Output = T> + Copy,

type Output = VecN<T, 4>

impl<T> Mul<Unit<DualQuaternion<T>>> for Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<T> Mul<Unit<DualQuaternion<T>>> for Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<T> Mul<Unit<DualQuaternion<T>>> for DualQuaternion<T>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = DualQuaternion<T>

impl<T> Mul<Unit<DualQuaternion<T>>> for Isometry<T, Unit<Quaternion<T>>, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<T> Mul<Unit<DualQuaternion<T>>> for Translation<T, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<T> Mul<Unit<Quaternion<T>>> for Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<T> Mul<Unit<Quaternion<T>>> for Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Quaternion<T>>

impl<T> Mul<Unit<Quaternion<T>>> for Isometry<T, Unit<Quaternion<T>>, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Quaternion<T>>, 3>

impl<T> Mul<Unit<Quaternion<T>>> for Rotation<T, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Quaternion<T>>

impl<T> Mul<Unit<Quaternion<T>>> for Similarity<T, Unit<Quaternion<T>>, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Unit<Quaternion<T>>, 3>

impl<T> Mul<Unit<Quaternion<T>>> for Translation<T, 3>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Quaternion<T>>, 3>

impl<T> Mul<Unit<Complex<T>>> for Unit<Complex<T>>where T: SimdRealField,

type Output = Unit<Complex<T>>

impl<T> Mul<Unit<Complex<T>>> for Isometry<T, Unit<Complex<T>>, 2>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Complex<T>>, 2>

impl<T> Mul<Unit<Complex<T>>> for Rotation<T, 2>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Complex<T>>

impl<T> Mul<Unit<Complex<T>>> for Similarity<T, Unit<Complex<T>>, 2>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Unit<Complex<T>>, 2>

impl<T> Mul<Unit<Complex<T>>> for Translation<T, 2>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Complex<T>>, 2>

impl<T> Mul<DualQuaternion<T>> for Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = DualQuaternion<T>

impl<T> Mul<DualQuaternion<T>> for DualQuaternion<T>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = DualQuaternion<T>

impl<T> Mul<Isometry<T, Unit<Quaternion<T>>, 3>> for Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<T> Mul<Isometry<T, Unit<Quaternion<T>>, 3>> for Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Quaternion<T>>, 3>

impl<T> Mul<Isometry<T, Unit<Complex<T>>, 2>> for Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Complex<T>>, 2>

impl<T> Mul<OPoint<T, Const<2>>> for Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = OPoint<T, Const<2>>

impl<T> Mul<OPoint<T, Const<3>>> for Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = OPoint<T, Const<3>>

impl<T> Mul<OPoint<T, Const<3>>> for Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = OPoint<T, Const<3>>

impl<T> Mul<Quaternion<T>> for Quaternion<T>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Quaternion<T>

impl<T> Mul<Rotation<T, 2>> for Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Complex<T>>

impl<T> Mul<Rotation<T, 3>> for Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Quaternion<T>>

impl<T> Mul<Similarity<T, Unit<Quaternion<T>>, 3>> for Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Unit<Quaternion<T>>, 3>

impl<T> Mul<Similarity<T, Unit<Complex<T>>, 2>> for Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Unit<Complex<T>>, 2>

impl<T> Mul<Translation<T, 2>> for Unit<Complex<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Complex<T>>, 2>

impl<T> Mul<Translation<T, 3>> for Unit<DualQuaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<DualQuaternion<T>>

impl<T> Mul<Translation<T, 3>> for Unit<Quaternion<T>>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Unit<Quaternion<T>>, 3>

impl<T> Mul<Ratio<T>> for Ratio<T>where T: Clone + Integer,

type Output = Ratio<T>

impl<T> Mul<Complex<T>> for Complex<T>where T: Clone + Num,

type Output = Complex<T>

impl<T> Mul<T> for Point3_<T>where Point3_<T>: MulAssign<T>,

type Output = Point3_<T>

impl<T> Mul<T> for Point_<T>where Point_<T>: MulAssign<T>,

type Output = Point_<T>

impl<T> Mul<T> for Size_<T>where Size_<T>: MulAssign<T>,

type Output = Size_<T>

impl<T> Mul<T> for DualQuaternion<T>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = DualQuaternion<T>

impl<T> Mul<T> for Quaternion<T>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Quaternion<T>

impl<T> Mul<T> for Ratio<T>where T: Clone + Integer,

type Output = Ratio<T>

impl<T> Mul<T> for Complex<T>where T: Clone + Num,

type Output = Complex<T>

impl<T, C> Mul<Unit<Quaternion<T>>> for Transform<T, C, 3>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, C: TCategoryMul<TAffine>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, 3>

impl<T, C> Mul<Unit<Complex<T>>> for Transform<T, C, 2>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, C: TCategoryMul<TAffine>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, 2>

impl<T, C> Mul<Transform<T, C, 2>> for Unit<Complex<T>>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, C: TCategoryMul<TAffine>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, 2>

impl<T, C> Mul<Transform<T, C, 3>> for Unit<Quaternion<T>>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, C: TCategoryMul<TAffine>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, 3>

impl<T, C, R, const D: usize> Mul<Isometry<T, R, D>> for Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer>>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<T, C, R, const D: usize> Mul<Similarity<T, R, D>> for Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer>>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<T, C, R, const D: usize> Mul<Transform<T, C, D>> for Isometry<T, R, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer>>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<T, C, R, const D: usize> Mul<Transform<T, C, D>> for Similarity<T, R, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer>>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<T, C, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategory, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>

impl<T, C, const D: usize> Mul<OPoint<T, Const<D>>> for Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategory, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = OPoint<T, Const<D>>

impl<T, C, const D: usize> Mul<Rotation<T, D>> for Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<T, C, const D: usize> Mul<Transform<T, C, D>> for Rotation<T, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<T, C, const D: usize> Mul<Transform<T, C, D>> for Translation<T, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<T, C, const D: usize> Mul<Translation<T, D>> for Transform<T, C, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <C as TCategoryMul<TAffine>>::Representative, D>

impl<T, CA, CB, const D: usize> Mul<Transform<T, CB, D>> for Transform<T, CA, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField, Const<D>: DimNameAdd<Const<1>>, CA: TCategoryMul<CB>, CB: TCategory, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

type Output = Transform<T, <CA as TCategoryMul<CB>>::Representative, D>

impl<T, D> Mul<T> for OPoint<T, D>where T: Scalar + ClosedMul<T>, D: DimName, DefaultAllocator: Allocator<T, D, Const<1>>,

type Output = OPoint<T, D>

impl<T, R1, C1, R2, C2, SA, SB> Mul<Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA>where R1: Dim, C1: Dim, R2: Dim, C2: Dim, T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, SB: Storage<T, R2, C2>, SA: Storage<T, R1, C1>, DefaultAllocator: Allocator<T, R1, C2>, ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,

type Output = Matrix<T, R1, C2, <DefaultAllocator as Allocator<T, R1, C2>>::Buffer>

impl<T, R1, C1, SA, const D2: usize> Mul<Rotation<T, D2>> for Matrix<T, R1, C1, SA>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>, DefaultAllocator: Allocator<T, R1, Const<D2>>, ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,

type Output = Matrix<T, R1, Const<D2>, <DefaultAllocator as Allocator<T, R1, Const<D2>>>::Buffer>

impl<T, R2, C2, SB, const D1: usize> Mul<Matrix<T, R2, C2, SB>> for Rotation<T, D1>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, R2: Dim, C2: Dim, SB: Storage<T, R2, C2>, DefaultAllocator: Allocator<T, Const<D1>, C2>, ShapeConstraint: AreMultipliable<Const<D1>, Const<D1>, R2, C2>,

type Output = Matrix<T, Const<D1>, C2, <DefaultAllocator as Allocator<T, Const<D1>, C2>>::Buffer>

impl<T, R, C, S> Mul<T> for Matrix<T, R, C, S>where R: Dim, C: Dim, T: Scalar + ClosedMul<T>, S: Storage<T, R, C>, DefaultAllocator: Allocator<T, R, C>,

type Output = Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>

impl<T, R, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>

impl<T, R, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Similarity<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>

impl<T, R, const D: usize> Mul<Unit<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>>> for Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Unit<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>>

impl<T, R, const D: usize> Mul<Isometry<T, R, D>> for Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Isometry<T, R, D>

impl<T, R, const D: usize> Mul<Isometry<T, R, D>> for Similarity<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Similarity<T, R, D>

impl<T, R, const D: usize> Mul<Isometry<T, R, D>> for Translation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Isometry<T, R, D>

impl<T, R, const D: usize> Mul<OPoint<T, Const<D>>> for Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = OPoint<T, Const<D>>

impl<T, R, const D: usize> Mul<OPoint<T, Const<D>>> for Similarity<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = OPoint<T, Const<D>>

impl<T, R, const D: usize> Mul<Similarity<T, R, D>> for Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Similarity<T, R, D>

impl<T, R, const D: usize> Mul<Similarity<T, R, D>> for Similarity<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Similarity<T, R, D>

impl<T, R, const D: usize> Mul<Similarity<T, R, D>> for Translation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Similarity<T, R, D>

impl<T, R, const D: usize> Mul<Translation<T, D>> for Isometry<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Isometry<T, R, D>

impl<T, R, const D: usize> Mul<Translation<T, D>> for Similarity<T, R, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

type Output = Similarity<T, R, D>

impl<T, S> Mul<Matrix<T, Const<2>, Const<1>, S>> for Unit<Complex<T>>where T: SimdRealField, S: Storage<T, Const<2>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Matrix<T, Const<nalgebra::::base::dimension::U2::{constant#0}>, Const<1>, ArrayStorage<T, 2, 1>>

impl<T, S> Mul<Unit<Matrix<T, Const<2>, Const<1>, S>>> for Unit<Complex<T>>where T: SimdRealField, S: Storage<T, Const<2>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Matrix<T, Const<nalgebra::::base::dimension::U2::{constant#0}>, Const<1>, ArrayStorage<T, 2, 1>>>

impl<T, S, const D: usize> Mul<Unit<Matrix<T, Const<D>, Const<1>, S>>> for Rotation<T, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, S: Storage<T, Const<D>, Const<1>>, ShapeConstraint: AreMultipliable<Const<D>, Const<D>, Const<D>, Const<1>>,

type Output = Unit<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>>

impl<T, SA, const D2: usize, const R1: usize, const C1: usize> Mul<OPoint<T, Const<D2>>> for Matrix<T, Const<R1>, Const<C1>, SA>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, SA: Storage<T, Const<R1>, Const<C1>>, ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, Const<1>>,

type Output = OPoint<T, Const<R1>>

impl<T, SB> Mul<Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, SB>> for Unit<DualQuaternion<T>>where T: SimdRealField, SB: Storage<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, ArrayStorage<T, 3, 1>>

impl<T, SB> Mul<Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, SB>> for Unit<Quaternion<T>>where T: SimdRealField, SB: Storage<T, Const<3>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, ArrayStorage<T, 3, 1>>

impl<T, SB> Mul<Unit<Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, SB>>> for Unit<DualQuaternion<T>>where T: SimdRealField, SB: Storage<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, ArrayStorage<T, 3, 1>>>

impl<T, SB> Mul<Unit<Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, SB>>> for Unit<Quaternion<T>>where T: SimdRealField, SB: Storage<T, Const<3>, Const<1>>, <T as SimdValue>::Element: SimdRealField,

type Output = Unit<Matrix<T, Const<nalgebra::::base::dimension::U3::{constant#0}>, Const<1>, ArrayStorage<T, 3, 1>>>

impl<T, const D: usize> Mul<Isometry<T, Rotation<T, D>, D>> for Rotation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Rotation<T, D>, D>

impl<T, const D: usize> Mul<OPoint<T, Const<D>>> for Rotation<T, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>, ShapeConstraint: AreMultipliable<Const<D>, Const<D>, Const<D>, Const<1>>,

type Output = OPoint<T, Const<D>>

impl<T, const D: usize> Mul<OPoint<T, Const<D>>> for Translation<T, D>where T: Scalar + ClosedAdd<T>, ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<Const<1>, Const<1>, Representative = Const<1>>,

type Output = OPoint<T, Const<D>>

impl<T, const D: usize> Mul<Rotation<T, D>> for Isometry<T, Rotation<T, D>, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Rotation<T, D>, D>

impl<T, const D: usize> Mul<Rotation<T, D>> for Rotation<T, D>where T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,

type Output = Rotation<T, D>

impl<T, const D: usize> Mul<Rotation<T, D>> for Similarity<T, Rotation<T, D>, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Rotation<T, D>, D>

impl<T, const D: usize> Mul<Rotation<T, D>> for Translation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Rotation<T, D>, D>

impl<T, const D: usize> Mul<Similarity<T, Rotation<T, D>, D>> for Rotation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Similarity<T, Rotation<T, D>, D>

impl<T, const D: usize> Mul<Translation<T, D>> for Rotation<T, D>where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

type Output = Isometry<T, Rotation<T, D>, D>

impl<T, const D: usize> Mul<Translation<T, D>> for Translation<T, D>where T: Scalar + ClosedAdd<T>, ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<Const<1>, Const<1>, Representative = Const<1>>,

type Output = Translation<T, D>

impl<T, const LANES: usize> Mul<&Simd<T, LANES>> for Simd<T, LANES>where T: SimdElement, Simd<T, LANES>: Mul<Simd<T, LANES>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

impl<T, const LANES: usize> Mul<Simd<T, LANES>> for &Simd<T, LANES>where T: SimdElement, Simd<T, LANES>: Mul<Simd<T, LANES>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

impl<U> Mul<ATerm> for NInt<U>where U: Unsigned + NonZero,

type Output = ATerm

impl<U> Mul<ATerm> for PInt<U>where U: Unsigned + NonZero,

type Output = ATerm

impl<U> Mul<Z0> for NInt<U>where U: Unsigned + NonZero,

N * Z0 = Z0

type Output = Z0

impl<U> Mul<Z0> for PInt<U>where U: Unsigned + NonZero,

P * Z0 = Z0

type Output = Z0

impl<U> Mul<U> for UTermwhere U: Unsigned,

UTerm * U = UTerm

type Output = UTerm

impl<U, B> Mul<B0> for UInt<U, B>where U: Unsigned, B: Bit,

UInt * B0 = UTerm

type Output = UTerm

impl<U, B> Mul<B1> for UInt<U, B>where U: Unsigned, B: Bit,

UInt * B1 = UInt

type Output = UInt<U, B>

impl<U, B> Mul<UTerm> for UInt<U, B>where U: Unsigned, B: Bit,

UInt<U, B> * UTerm = UTerm

type Output = UTerm

impl<Ul, B, Ur> Mul<UInt<Ur, B>> for UInt<Ul, B0>where Ul: Unsigned + Mul<UInt<Ur, B>>, B: Bit, Ur: Unsigned,

UInt<Ul, B0> * UInt<Ur, B> = UInt<(Ul * UInt<Ur, B>), B0>

type Output = UInt<<Ul as Mul<UInt<Ur, B>>>::Output, B0>

impl<Ul, B, Ur> Mul<UInt<Ur, B>> for UInt<Ul, B1>where Ul: Unsigned + Mul<UInt<Ur, B>>, B: Bit, Ur: Unsigned, UInt<<Ul as Mul<UInt<Ur, B>>>::Output, B0>: Add<UInt<Ur, B>>,

UInt<Ul, B1> * UInt<Ur, B> = UInt<(Ul * UInt<Ur, B>), B0> + UInt<Ur, B>

type Output = <UInt<<Ul as Mul<UInt<Ur, B>>>::Output, B0> as Add<UInt<Ur, B>>>::Output

impl<Ul, Ur> Mul<NInt<Ur>> for NInt<Ul>where Ul: Unsigned + NonZero + Mul<Ur>, Ur: Unsigned + NonZero, <Ul as Mul<Ur>>::Output: Unsigned + NonZero,

N(Ul) * N(Ur) = P(Ul * Ur)

type Output = PInt<<Ul as Mul<Ur>>::Output>

impl<Ul, Ur> Mul<NInt<Ur>> for PInt<Ul>where Ul: Unsigned + NonZero + Mul<Ur>, Ur: Unsigned + NonZero, <Ul as Mul<Ur>>::Output: Unsigned + NonZero,

P(Ul) * N(Ur) = N(Ul * Ur)

type Output = NInt<<Ul as Mul<Ur>>::Output>

impl<Ul, Ur> Mul<PInt<Ur>> for NInt<Ul>where Ul: Unsigned + NonZero + Mul<Ur>, Ur: Unsigned + NonZero, <Ul as Mul<Ur>>::Output: Unsigned + NonZero,

N(Ul) * P(Ur) = N(Ul * Ur)

type Output = NInt<<Ul as Mul<Ur>>::Output>

impl<Ul, Ur> Mul<PInt<Ur>> for PInt<Ul>where Ul: Unsigned + NonZero + Mul<Ur>, Ur: Unsigned + NonZero, <Ul as Mul<Ur>>::Output: Unsigned + NonZero,

P(Ul) * P(Ur) = P(Ul * Ur)

type Output = PInt<<Ul as Mul<Ur>>::Output>

impl<V, A> Mul<TArr<V, A>> for Z0where Z0: Mul<A>,

type Output = TArr<Z0, <Z0 as Mul<A>>::Output>

impl<V, A, Rhs> Mul<Rhs> for TArr<V, A>where V: Mul<Rhs>, A: Mul<Rhs>, Rhs: Copy,

type Output = TArr<<V as Mul<Rhs>>::Output, <A as Mul<Rhs>>::Output>

impl<V, A, U> Mul<TArr<V, A>> for NInt<U>where U: Unsigned + NonZero, NInt<U>: Mul<A> + Mul<V>,

type Output = TArr<<NInt<U> as Mul<V>>::Output, <NInt<U> as Mul<A>>::Output>

impl<V, A, U> Mul<TArr<V, A>> for PInt<U>where U: Unsigned + NonZero, PInt<U>: Mul<A> + Mul<V>,

type Output = TArr<<PInt<U> as Mul<V>>::Output, <PInt<U> as Mul<A>>::Output>

impl<const N: usize> Mul<Simd<f32, N>> for Simd<f32, N>where f32: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<f32, N>

impl<const N: usize> Mul<Simd<f64, N>> for Simd<f64, N>where f64: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<f64, N>

impl<const N: usize> Mul<Simd<i8, N>> for Simd<i8, N>where i8: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<i8, N>

impl<const N: usize> Mul<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<i16, N>

impl<const N: usize> Mul<Simd<i32, N>> for Simd<i32, N>where i32: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<i32, N>

impl<const N: usize> Mul<Simd<i64, N>> for Simd<i64, N>where i64: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<i64, N>

impl<const N: usize> Mul<Simd<isize, N>> for Simd<isize, N>where isize: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<isize, N>

impl<const N: usize> Mul<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<u8, N>

impl<const N: usize> Mul<Simd<u16, N>> for Simd<u16, N>where u16: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<u16, N>

impl<const N: usize> Mul<Simd<u32, N>> for Simd<u32, N>where u32: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<u32, N>

impl<const N: usize> Mul<Simd<u64, N>> for Simd<u64, N>where u64: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<u64, N>

impl<const N: usize> Mul<Simd<usize, N>> for Simd<usize, N>where usize: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<usize, N>