Trait tract_hir::internal::tract_downcast_rs::__std::ops::Mul

#[lang = "mul"]pub trait Mul<Rhs = Self> {
    type Output;
#[must_use]    pub 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] });

Associated Types

type Output

The resulting type after applying the * operator.

Loading content...

Required methods

#[must_use]pub fn mul(self, rhs: Rhs) -> Self::Output

Performs the * operation.

Example

assert_eq!(12 * 2, 24);

Loading content...

Implementations on Foreign Types

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

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

pub fn mul(self, other: &u8) -> <u8 as Mul<u8>>::Output

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

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

pub fn mul(self, other: &u128) -> <u128 as Mul<u128>>::Output

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

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

pub fn mul(self, other: &usize) -> <usize as Mul<usize>>::Output

impl Mul<i8> for i8

type Output = i8

pub fn mul(self, other: i8) -> i8

impl Mul<f32> for f32

type Output = f32

pub fn mul(self, other: f32) -> f32

impl Mul<i32> for i32

type Output = i32

pub fn mul(self, other: i32) -> i32

impl<'_, '_> Mul<&'_ f64> for &'_ f64

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

pub fn mul(self, other: &f64) -> <f64 as Mul<f64>>::Output

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

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

pub fn mul(self, other: i16) -> <i16 as Mul<i16>>::Output

impl<'_, '_> Mul<&'_ i64> for &'_ i64

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

pub fn mul(self, other: &i64) -> <i64 as Mul<i64>>::Output

impl Mul<u16> for u16

type Output = u16

pub fn mul(self, other: u16) -> u16

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

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

pub fn mul(self, other: i64) -> <i64 as Mul<i64>>::Output

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

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

pub fn mul(self, other: &i32) -> <i32 as Mul<i32>>::Output

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

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

pub fn mul(self, other: &i16) -> <i16 as Mul<i16>>::Output

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

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

pub fn mul(self, other: &i8) -> <i8 as Mul<i8>>::Output

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

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

pub fn mul(self, other: &f32) -> <f32 as Mul<f32>>::Output

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

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

pub fn mul(self, other: u8) -> <u8 as Mul<u8>>::Output

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

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

pub fn mul(self, other: &f64) -> <f64 as Mul<f64>>::Output

impl<'_, '_> Mul<&'_ isize> for &'_ isize

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

pub fn mul(self, other: &isize) -> <isize as Mul<isize>>::Output

impl Mul<f64> for f64

type Output = f64

pub fn mul(self, other: f64) -> f64

impl<'_, '_> Mul<&'_ i128> for &'_ i128

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

pub fn mul(self, other: &i128) -> <i128 as Mul<i128>>::Output

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

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

pub fn mul(self, other: u32) -> <u32 as Mul<u32>>::Output

impl<'_, '_> Mul<&'_ i32> for &'_ i32

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

pub fn mul(self, other: &i32) -> <i32 as Mul<i32>>::Output

impl Mul<u32> for u32

type Output = u32

pub fn mul(self, other: u32) -> u32

impl<'_, '_> Mul<&'_ u16> for &'_ u16

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

pub fn mul(self, other: &u16) -> <u16 as Mul<u16>>::Output

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

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

pub fn mul(self, other: &i128) -> <i128 as Mul<i128>>::Output

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

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

pub fn mul(self, other: i8) -> <i8 as Mul<i8>>::Output

impl<'_, '_> Mul<&'_ u64> for &'_ u64

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

pub fn mul(self, other: &u64) -> <u64 as Mul<u64>>::Output

impl Mul<u8> for u8

type Output = u8

pub fn mul(self, other: u8) -> u8

impl Mul<Duration> for u32

type Output = Duration

pub fn mul(self, rhs: Duration) -> Duration

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

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

pub fn mul(self, other: u64) -> <u64 as Mul<u64>>::Output

impl<'_, '_> Mul<&'_ f32> for &'_ f32

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

pub fn mul(self, other: &f32) -> <f32 as Mul<f32>>::Output

impl Mul<i128> for i128

type Output = i128

pub fn mul(self, other: i128) -> i128

impl<'_, '_> Mul<&'_ u128> for &'_ u128

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

pub fn mul(self, other: &u128) -> <u128 as Mul<u128>>::Output

impl Mul<i16> for i16

type Output = i16

pub fn mul(self, other: i16) -> i16

impl<'_, '_> Mul<&'_ u32> for &'_ u32

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

pub fn mul(self, other: &u32) -> <u32 as Mul<u32>>::Output

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

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

pub fn mul(self, other: i32) -> <i32 as Mul<i32>>::Output

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

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

pub fn mul(self, other: &i64) -> <i64 as Mul<i64>>::Output

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

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

pub fn mul(self, other: &u16) -> <u16 as Mul<u16>>::Output

impl Mul<u128> for u128

type Output = u128

pub fn mul(self, other: u128) -> u128

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

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

pub fn mul(self, other: u16) -> <u16 as Mul<u16>>::Output

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

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

pub fn mul(self, other: usize) -> <usize as Mul<usize>>::Output

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

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

pub fn mul(self, other: i128) -> <i128 as Mul<i128>>::Output

impl<'_, '_> Mul<&'_ i16> for &'_ i16

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

pub fn mul(self, other: &i16) -> <i16 as Mul<i16>>::Output

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

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

pub fn mul(self, other: &isize) -> <isize as Mul<isize>>::Output

impl Mul<isize> for isize

type Output = isize

pub fn mul(self, other: isize) -> isize

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

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

pub fn mul(self, other: f32) -> <f32 as Mul<f32>>::Output

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

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

pub fn mul(self, other: isize) -> <isize as Mul<isize>>::Output

impl Mul<i64> for i64

type Output = i64

pub fn mul(self, other: i64) -> i64

impl<'_, '_> Mul<&'_ i8> for &'_ i8

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

pub fn mul(self, other: &i8) -> <i8 as Mul<i8>>::Output

impl Mul<u64> for u64

type Output = u64

pub fn mul(self, other: u64) -> u64

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

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

pub fn mul(self, other: &u32) -> <u32 as Mul<u32>>::Output

impl<'_, '_> Mul<&'_ u8> for &'_ u8

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

pub fn mul(self, other: &u8) -> <u8 as Mul<u8>>::Output

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

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

pub fn mul(self, other: &u64) -> <u64 as Mul<u64>>::Output

impl<'_, '_> Mul<&'_ usize> for &'_ usize

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

pub fn mul(self, other: &usize) -> <usize as Mul<usize>>::Output

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

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

pub fn mul(self, other: f64) -> <f64 as Mul<f64>>::Output

impl Mul<usize> for usize

type Output = usize

pub fn mul(self, other: usize) -> usize

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

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

pub fn mul(self, other: u128) -> <u128 as Mul<u128>>::Output

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

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

pub fn mul(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i16>, D>

impl<S, D> Mul<ArrayBase<S, D>> for u8 where
    S: DataOwned<Elem = u8> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn mul(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Mul<ArrayBase<S, D>> for u64 where
    S: DataOwned<Elem = u64> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn mul(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Mul<ArrayBase<S, D>> for f32 where
    S: DataOwned<Elem = f32> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn mul(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

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

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

pub fn mul(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u8>, 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>

pub fn mul(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

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

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

pub fn mul(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<f64>, D>

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

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

pub fn mul(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u64>, D>

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

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

pub fn mul(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<f32>, D>

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

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

pub fn mul(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i64>, D>

impl<S, D> Mul<ArrayBase<S, D>> for u32 where
    S: DataOwned<Elem = u32> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn mul(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Mul<ArrayBase<S, D>> for i64 where
    S: DataOwned<Elem = i64> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn mul(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, 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>

pub fn mul(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<Complex<f32>>, D>

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

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

pub fn mul(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u128>, 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>

pub fn mul(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<Complex<f64>>, D>

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

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

pub fn mul(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i128>, D>

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

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

pub fn mul(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i32>, D>

impl<S, D> Mul<ArrayBase<S, D>> for f64 where
    S: DataOwned<Elem = f64> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn mul(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

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

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

pub fn mul(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u32>, D>

impl<S, D> Mul<ArrayBase<S, D>> for i32 where
    S: DataOwned<Elem = i32> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn mul(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

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

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

pub fn mul(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u16>, D>

impl<S, D> Mul<ArrayBase<S, D>> for u16 where
    S: DataOwned<Elem = u16> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn mul(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Mul<ArrayBase<S, D>> for u128 where
    S: DataOwned<Elem = u128> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn mul(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Mul<ArrayBase<S, D>> for i8 where
    S: DataOwned<Elem = i8> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn mul(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Mul<ArrayBase<S, D>> for i128 where
    S: DataOwned<Elem = i128> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn mul(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

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

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

pub fn mul(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i8>, D>

impl<S, D> Mul<ArrayBase<S, D>> for i16 where
    S: DataOwned<Elem = i16> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn mul(self, rhs: ArrayBase<S, D>) -> 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>

pub fn mul(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

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

type Output = Complex<u128>

pub fn mul(self, other: Complex<u128>) -> Complex<u128>

impl Mul<Complex<isize>> for isize

type Output = Complex<isize>

pub fn mul(
    self,
    other: Complex<isize>
) -> <isize as Mul<Complex<isize>>>::Output

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

type Output = Complex<T>

pub fn mul(self, other: Complex<T>) -> <Complex<T> as Mul<Complex<T>>>::Output

impl Mul<Complex<u128>> for u128

type Output = Complex<u128>

pub fn mul(self, other: Complex<u128>) -> <u128 as Mul<Complex<u128>>>::Output

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

type Output = Complex<u8>

pub fn mul(self, other: Complex<u8>) -> Complex<u8>

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

type Output = Complex<T>

pub fn mul(
    self,
    other: &Complex<T>
) -> <Complex<T> as Mul<&'a Complex<T>>>::Output

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

type Output = Complex<T>

pub fn mul(
    self,
    other: Complex<T>
) -> <&'a Complex<T> as Mul<Complex<T>>>::Output

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

type Output = Complex<T>

pub fn mul(self, other: &T) -> <Complex<T> as Mul<&'a T>>::Output

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

type Output = Complex<u32>

pub fn mul(self, other: &Complex<u32>) -> Complex<u32>

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

type Output = Complex<isize>

pub fn mul(self, other: &Complex<isize>) -> Complex<isize>

impl Mul<Complex<u64>> for u64

type Output = Complex<u64>

pub fn mul(self, other: Complex<u64>) -> <u64 as Mul<Complex<u64>>>::Output

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

type Output = Complex<i64>

pub fn mul(self, other: &Complex<i64>) -> Complex<i64>

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

type Output = Complex<i8>

pub fn mul(self, other: Complex<i8>) -> Complex<i8>

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

type Output = Complex<i16>

pub fn mul(self, other: &Complex<i16>) -> Complex<i16>

impl Mul<Complex<f64>> for f64

type Output = Complex<f64>

pub fn mul(self, other: Complex<f64>) -> <f64 as Mul<Complex<f64>>>::Output

impl Mul<Complex<usize>> for usize

type Output = Complex<usize>

pub fn mul(
    self,
    other: Complex<usize>
) -> <usize as Mul<Complex<usize>>>::Output

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

type Output = Complex<f32>

pub fn mul(self, other: Complex<f32>) -> Complex<f32>

impl Mul<Complex<f32>> for f32

type Output = Complex<f32>

pub fn mul(self, other: Complex<f32>) -> <f32 as Mul<Complex<f32>>>::Output

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

type Output = Complex<i64>

pub fn mul(self, other: &Complex<i64>) -> Complex<i64>

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

type Output = Complex<i128>

pub fn mul(self, other: &Complex<i128>) -> Complex<i128>

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

type Output = Complex<u8>

pub fn mul(self, other: &Complex<u8>) -> Complex<u8>

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

type Output = Complex<f64>

pub fn mul(self, other: &Complex<f64>) -> Complex<f64>

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

type Output = Complex<usize>

pub fn mul(self, other: Complex<usize>) -> Complex<usize>

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

type Output = Complex<i32>

pub fn mul(self, other: Complex<i32>) -> Complex<i32>

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

type Output = Complex<u128>

pub fn mul(self, other: &Complex<u128>) -> Complex<u128>

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

type Output = Complex<i32>

pub fn mul(self, other: &Complex<i32>) -> Complex<i32>

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

type Output = Complex<u64>

pub fn mul(self, other: Complex<u64>) -> Complex<u64>

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

type Output = Complex<f64>

pub fn mul(self, other: Complex<f64>) -> Complex<f64>

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

type Output = Complex<T>

pub fn mul(self, other: &T) -> <&'b Complex<T> as Mul<&'a T>>::Output

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

type Output = Complex<isize>

pub fn mul(self, other: &Complex<isize>) -> Complex<isize>

impl Mul<Complex<i128>> for i128

type Output = Complex<i128>

pub fn mul(self, other: Complex<i128>) -> <i128 as Mul<Complex<i128>>>::Output

impl Mul<Complex<u8>> for u8

type Output = Complex<u8>

pub fn mul(self, other: Complex<u8>) -> <u8 as Mul<Complex<u8>>>::Output

impl Mul<Complex<i32>> for i32

type Output = Complex<i32>

pub fn mul(self, other: Complex<i32>) -> <i32 as Mul<Complex<i32>>>::Output

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

type Output = Complex<u64>

pub fn mul(self, other: &Complex<u64>) -> Complex<u64>

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

type Output = Complex<u128>

pub fn mul(self, other: &Complex<u128>) -> Complex<u128>

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

type Output = Complex<i8>

pub fn mul(self, other: &Complex<i8>) -> Complex<i8>

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

type Output = Complex<u16>

pub fn mul(self, other: &Complex<u16>) -> Complex<u16>

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

type Output = Complex<isize>

pub fn mul(self, other: Complex<isize>) -> Complex<isize>

impl Mul<Complex<i64>> for i64

type Output = Complex<i64>

pub fn mul(self, other: Complex<i64>) -> <i64 as Mul<Complex<i64>>>::Output

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

type Output = Complex<T>

pub fn mul(self, other: T) -> <&'a Complex<T> as Mul<T>>::Output

impl Mul<Complex<u32>> for u32

type Output = Complex<u32>

pub fn mul(self, other: Complex<u32>) -> <u32 as Mul<Complex<u32>>>::Output

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

type Output = Complex<u32>

pub fn mul(self, other: &Complex<u32>) -> Complex<u32>

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

type Output = Complex<T>

pub fn mul(
    self,
    other: &Complex<T>
) -> <&'a Complex<T> as Mul<&'b Complex<T>>>::Output

impl Mul<Complex<i16>> for i16

type Output = Complex<i16>

pub fn mul(self, other: Complex<i16>) -> <i16 as Mul<Complex<i16>>>::Output

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

type Output = Complex<u64>

pub fn mul(self, other: &Complex<u64>) -> Complex<u64>

impl Mul<Complex<u16>> for u16

type Output = Complex<u16>

pub fn mul(self, other: Complex<u16>) -> <u16 as Mul<Complex<u16>>>::Output

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

type Output = Complex<i16>

pub fn mul(self, other: Complex<i16>) -> Complex<i16>

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

type Output = Complex<i128>

pub fn mul(self, other: &Complex<i128>) -> Complex<i128>

impl Mul<Complex<i8>> for i8

type Output = Complex<i8>

pub fn mul(self, other: Complex<i8>) -> <i8 as Mul<Complex<i8>>>::Output

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

type Output = Complex<usize>

pub fn mul(self, other: &Complex<usize>) -> Complex<usize>

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

type Output = Complex<usize>

pub fn mul(self, other: &Complex<usize>) -> Complex<usize>

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

type Output = Complex<T>

pub fn mul(self, other: T) -> <Complex<T> as Mul<T>>::Output

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

type Output = Complex<i8>

pub fn mul(self, other: &Complex<i8>) -> Complex<i8>

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

type Output = Complex<i64>

pub fn mul(self, other: Complex<i64>) -> Complex<i64>

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

type Output = Complex<f32>

pub fn mul(self, other: &Complex<f32>) -> Complex<f32>

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

type Output = Complex<u16>

pub fn mul(self, other: &Complex<u16>) -> Complex<u16>

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

type Output = Complex<f64>

pub fn mul(self, other: &Complex<f64>) -> Complex<f64>

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

type Output = Complex<i128>

pub fn mul(self, other: Complex<i128>) -> Complex<i128>

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

type Output = Complex<f32>

pub fn mul(self, other: &Complex<f32>) -> Complex<f32>

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

type Output = Complex<i32>

pub fn mul(self, other: &Complex<i32>) -> Complex<i32>

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

type Output = Complex<u32>

pub fn mul(self, other: Complex<u32>) -> Complex<u32>

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

type Output = Complex<u16>

pub fn mul(self, other: Complex<u16>) -> Complex<u16>

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

type Output = Complex<u8>

pub fn mul(self, other: &Complex<u8>) -> Complex<u8>

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

type Output = Complex<i16>

pub fn mul(self, other: &Complex<i16>) -> Complex<i16>

impl Mul<Exp<GenericFactoid<i64>>> for i64

type Output = Exp<IntFactoid>

fn mul(self, other: Exp<IntFactoid>) -> Exp<IntFactoid>

impl Mul<Exp<GenericFactoid<TDim>>> for i64

type Output = Exp<DimFact>

fn mul(self, other: Exp<DimFact>) -> Exp<DimFact>

Loading content...

Implementors

impl Mul<u32> for Duration

type Output = Duration

pub fn mul(self, rhs: u32) -> Duration

impl Mul<f16> for f16

type Output = f16

pub fn mul(self, other: f16) -> f16

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

type Output = Wrapping<i8>

pub fn mul(self, other: Wrapping<i8>) -> Wrapping<i8>

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

type Output = Wrapping<i16>

pub fn mul(self, other: Wrapping<i16>) -> Wrapping<i16>

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

type Output = Wrapping<i32>

pub fn mul(self, other: Wrapping<i32>) -> Wrapping<i32>

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

type Output = Wrapping<i64>

pub fn mul(self, other: Wrapping<i64>) -> Wrapping<i64>

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

type Output = Wrapping<i128>

pub fn mul(self, other: Wrapping<i128>) -> Wrapping<i128>

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

type Output = Wrapping<isize>

pub fn mul(self, other: Wrapping<isize>) -> Wrapping<isize>

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

type Output = Wrapping<u8>

pub fn mul(self, other: Wrapping<u8>) -> Wrapping<u8>

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

type Output = Wrapping<u16>

pub fn mul(self, other: Wrapping<u16>) -> Wrapping<u16>

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

type Output = Wrapping<u32>

pub fn mul(self, other: Wrapping<u32>) -> Wrapping<u32>

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

type Output = Wrapping<u64>

pub fn mul(self, other: Wrapping<u64>) -> Wrapping<u64>

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

type Output = Wrapping<u128>

pub fn mul(self, other: Wrapping<u128>) -> Wrapping<u128>

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

type Output = Wrapping<usize>

pub fn mul(self, other: Wrapping<usize>) -> Wrapping<usize>

impl<'_> Mul<&'_ f16> for f16

type Output = f16

pub fn mul(self, other: &f16) -> f16

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

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

pub fn mul(
    self,
    other: &Wrapping<i8>
) -> <Wrapping<i8> as Mul<Wrapping<i8>>>::Output

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

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

pub fn mul(
    self,
    other: &Wrapping<i16>
) -> <Wrapping<i16> as Mul<Wrapping<i16>>>::Output

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

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

pub fn mul(
    self,
    other: &Wrapping<i32>
) -> <Wrapping<i32> as Mul<Wrapping<i32>>>::Output

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

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

pub fn mul(
    self,
    other: &Wrapping<i64>
) -> <Wrapping<i64> as Mul<Wrapping<i64>>>::Output

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

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

pub fn mul(
    self,
    other: &Wrapping<i128>
) -> <Wrapping<i128> as Mul<Wrapping<i128>>>::Output

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

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

pub fn mul(
    self,
    other: &Wrapping<isize>
) -> <Wrapping<isize> as Mul<Wrapping<isize>>>::Output

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

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

pub fn mul(
    self,
    other: &Wrapping<u8>
) -> <Wrapping<u8> as Mul<Wrapping<u8>>>::Output

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

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

pub fn mul(
    self,
    other: &Wrapping<u16>
) -> <Wrapping<u16> as Mul<Wrapping<u16>>>::Output

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

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

pub fn mul(
    self,
    other: &Wrapping<u32>
) -> <Wrapping<u32> as Mul<Wrapping<u32>>>::Output

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

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

pub fn mul(
    self,
    other: &Wrapping<u64>
) -> <Wrapping<u64> as Mul<Wrapping<u64>>>::Output

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

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

pub fn mul(
    self,
    other: &Wrapping<u128>
) -> <Wrapping<u128> as Mul<Wrapping<u128>>>::Output

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

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

pub fn mul(
    self,
    other: &Wrapping<usize>
) -> <Wrapping<usize> as Mul<Wrapping<usize>>>::Output

impl<'_, '_> Mul<&'_ Wrapping<i8>> for &'_ Wrapping<i8>

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

pub fn mul(
    self,
    other: &Wrapping<i8>
) -> <Wrapping<i8> as Mul<Wrapping<i8>>>::Output

impl<'_, '_> Mul<&'_ Wrapping<i16>> for &'_ Wrapping<i16>

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

pub fn mul(
    self,
    other: &Wrapping<i16>
) -> <Wrapping<i16> as Mul<Wrapping<i16>>>::Output

impl<'_, '_> Mul<&'_ Wrapping<i32>> for &'_ Wrapping<i32>

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

pub fn mul(
    self,
    other: &Wrapping<i32>
) -> <Wrapping<i32> as Mul<Wrapping<i32>>>::Output

impl<'_, '_> Mul<&'_ Wrapping<i64>> for &'_ Wrapping<i64>

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

pub fn mul(
    self,
    other: &Wrapping<i64>
) -> <Wrapping<i64> as Mul<Wrapping<i64>>>::Output

impl<'_, '_> Mul<&'_ Wrapping<i128>> for &'_ Wrapping<i128>

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

pub fn mul(
    self,
    other: &Wrapping<i128>
) -> <Wrapping<i128> as Mul<Wrapping<i128>>>::Output

impl<'_, '_> Mul<&'_ Wrapping<isize>> for &'_ Wrapping<isize>

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

pub fn mul(
    self,
    other: &Wrapping<isize>
) -> <Wrapping<isize> as Mul<Wrapping<isize>>>::Output

impl<'_, '_> Mul<&'_ Wrapping<u8>> for &'_ Wrapping<u8>

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

pub fn mul(
    self,
    other: &Wrapping<u8>
) -> <Wrapping<u8> as Mul<Wrapping<u8>>>::Output

impl<'_, '_> Mul<&'_ Wrapping<u16>> for &'_ Wrapping<u16>

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

pub fn mul(
    self,
    other: &Wrapping<u16>
) -> <Wrapping<u16> as Mul<Wrapping<u16>>>::Output

impl<'_, '_> Mul<&'_ Wrapping<u32>> for &'_ Wrapping<u32>

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

pub fn mul(
    self,
    other: &Wrapping<u32>
) -> <Wrapping<u32> as Mul<Wrapping<u32>>>::Output

impl<'_, '_> Mul<&'_ Wrapping<u64>> for &'_ Wrapping<u64>

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

pub fn mul(
    self,
    other: &Wrapping<u64>
) -> <Wrapping<u64> as Mul<Wrapping<u64>>>::Output

impl<'_, '_> Mul<&'_ Wrapping<u128>> for &'_ Wrapping<u128>

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

pub fn mul(
    self,
    other: &Wrapping<u128>
) -> <Wrapping<u128> as Mul<Wrapping<u128>>>::Output

impl<'_, '_> Mul<&'_ Wrapping<usize>> for &'_ Wrapping<usize>

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

pub fn mul(
    self,
    other: &Wrapping<usize>
) -> <Wrapping<usize> as Mul<Wrapping<usize>>>::Output

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

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

pub fn mul(
    self,
    other: Wrapping<i8>
) -> <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

pub fn mul(
    self,
    other: Wrapping<i16>
) -> <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

pub fn mul(
    self,
    other: Wrapping<i32>
) -> <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

pub fn mul(
    self,
    other: Wrapping<i64>
) -> <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

pub fn mul(
    self,
    other: Wrapping<i128>
) -> <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

pub fn mul(
    self,
    other: Wrapping<isize>
) -> <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

pub fn mul(
    self,
    other: Wrapping<u8>
) -> <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

pub fn mul(
    self,
    other: Wrapping<u16>
) -> <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

pub fn mul(
    self,
    other: Wrapping<u32>
) -> <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

pub fn mul(
    self,
    other: Wrapping<u64>
) -> <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

pub fn mul(
    self,
    other: Wrapping<u128>
) -> <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

pub fn mul(
    self,
    other: Wrapping<usize>
) -> <Wrapping<usize> as Mul<Wrapping<usize>>>::Output

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

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

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

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

pub fn mul(self, rhs: &'a ArrayBase<S2, E>) -> ArrayBase<OwnedRepr<A>, D>

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

Perform elementwise multiplication between self and reference rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

pub fn mul(self, rhs: &ArrayBase<S2, E>) -> ArrayBase<S, D>

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

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>

pub fn mul(self, x: B) -> ArrayBase<OwnedRepr<A>, D>

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

Perform elementwise multiplication between self and rhs, and return the result (based on self).

self must be an Array or ArcArray.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

pub fn mul(self, rhs: ArrayBase<S2, E>) -> ArrayBase<S, D>

impl<A, S, D, B> Mul<B> for ArrayBase<S, D> where
    S: DataOwned<Elem = A> + DataMut,
    A: Clone + Mul<B, Output = A>,
    B: ScalarOperand,
    D: Dimension, 

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>

pub fn mul(self, x: B) -> ArrayBase<S, D>

impl<I> Mul<usize> for Dim<I> where
    Dim<I>: Dimension, 

type Output = Dim<I>

pub fn mul(self, rhs: usize) -> Dim<I>

impl<I> Mul<Dim<I>> for Dim<I> where
    Dim<I>: Dimension, 

type Output = Dim<I>

pub fn mul(self, rhs: Dim<I>) -> Dim<I>

impl<I> Mul<I> for TDim where
    I: AsPrimitive<i64>, 

type Output = TDim

pub fn mul(self, rhs: I) -> TDim

impl<T, R> Mul<R> for GenericFactoid<T> where
    T: Mul<R, Output = T> + PartialEq + Clone + Debug + Hash, 

type Output = GenericFactoid<T>

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

Loading content...