Trait tract_hir::internal::tract_downcast_rs::__std::ops::Div

#[lang = "div"]pub trait Div<Rhs = Self> {
    type Output;
#[must_use]    pub fn div(self, rhs: Rhs) -> Self::Output;
}

The division operator /.

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

Examples

Dividable rational numbers

use std::ops::Div;

// 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 Div for Rational {
    // The division of rational numbers is a closed operation.
    type Output = Self;

    fn div(self, rhs: Self) -> Self::Output {
        if rhs.numerator == 0 {
            panic!("Cannot divide by zero-valued `Rational`!");
        }

        let numerator = self.numerator * rhs.denominator;
        let denominator = self.denominator * rhs.numerator;
        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(1, 2) / Rational::new(3, 4),
           Rational::new(2, 3));

Dividing vectors by scalars as in linear algebra

use std::ops::Div;

struct Scalar { value: f32 }

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

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

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

let scalar = Scalar { value: 2f32 };
let vector = Vector { value: vec![2f32, 4f32, 6f32] };
assert_eq!(vector / scalar, Vector { value: vec![1f32, 2f32, 3f32] });

Associated Types

type Output

The resulting type after applying the / operator.

Loading content...

Required methods

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

Performs the / operation.

Example

assert_eq!(12 / 2, 6);

Loading content...

Implementations on Foreign Types

impl Div<u32> for u32

This operation rounds towards zero, truncating any fractional part of the exact result.

Panics

This operation will panic if other == 0.

type Output = u32

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

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

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

pub fn div(self, other: &f64) -> <f64 as Div<f64>>::Output

impl Div<NonZeroU128> for u128

type Output = u128

pub fn div(self, other: NonZeroU128) -> u128

This operation rounds towards zero, truncating any fractional part of the exact result, and cannot panic.

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

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

pub fn div(self, other: &usize) -> <usize as Div<usize>>::Output

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

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

pub fn div(self, other: f64) -> <f64 as Div<f64>>::Output

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

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

pub fn div(self, other: &i16) -> <i16 as Div<i16>>::Output

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

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

pub fn div(self, other: isize) -> <isize as Div<isize>>::Output

impl Div<u128> for u128

This operation rounds towards zero, truncating any fractional part of the exact result.

Panics

This operation will panic if other == 0.

type Output = u128

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

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

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

pub fn div(self, other: u128) -> <u128 as Div<u128>>::Output

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

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

pub fn div(self, other: &u16) -> <u16 as Div<u16>>::Output

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

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

pub fn div(self, other: &u128) -> <u128 as Div<u128>>::Output

impl Div<NonZeroU16> for u16

type Output = u16

pub fn div(self, other: NonZeroU16) -> u16

This operation rounds towards zero, truncating any fractional part of the exact result, and cannot panic.

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

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

pub fn div(self, other: &isize) -> <isize as Div<isize>>::Output

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

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

pub fn div(self, other: &i64) -> <i64 as Div<i64>>::Output

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

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

pub fn div(self, other: &i8) -> <i8 as Div<i8>>::Output

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

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

pub fn div(self, other: &i128) -> <i128 as Div<i128>>::Output

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

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

pub fn div(self, other: u16) -> <u16 as Div<u16>>::Output

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

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

pub fn div(self, other: u32) -> <u32 as Div<u32>>::Output

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

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

pub fn div(self, other: &u8) -> <u8 as Div<u8>>::Output

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

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

pub fn div(self, other: &u32) -> <u32 as Div<u32>>::Output

impl Div<u16> for u16

This operation rounds towards zero, truncating any fractional part of the exact result.

Panics

This operation will panic if other == 0.

type Output = u16

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

impl Div<i128> for i128

This operation rounds towards zero, truncating any fractional part of the exact result.

Panics

This operation will panic if other == 0 or the division results in overflow.

type Output = i128

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

impl Div<NonZeroUsize> for usize

type Output = usize

pub fn div(self, other: NonZeroUsize) -> usize

This operation rounds towards zero, truncating any fractional part of the exact result, and cannot panic.

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

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

pub fn div(self, other: i16) -> <i16 as Div<i16>>::Output

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

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

pub fn div(self, other: usize) -> <usize as Div<usize>>::Output

impl Div<f32> for f32

type Output = f32

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

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

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

pub fn div(self, other: &i16) -> <i16 as Div<i16>>::Output

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

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

pub fn div(self, other: &i32) -> <i32 as Div<i32>>::Output

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

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

pub fn div(self, other: u8) -> <u8 as Div<u8>>::Output

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

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

pub fn div(self, other: u64) -> <u64 as Div<u64>>::Output

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

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

pub fn div(self, other: &u128) -> <u128 as Div<u128>>::Output

impl Div<isize> for isize

This operation rounds towards zero, truncating any fractional part of the exact result.

Panics

This operation will panic if other == 0 or the division results in overflow.

type Output = isize

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

impl Div<i32> for i32

This operation rounds towards zero, truncating any fractional part of the exact result.

Panics

This operation will panic if other == 0 or the division results in overflow.

type Output = i32

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

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

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

pub fn div(self, other: &u8) -> <u8 as Div<u8>>::Output

impl Div<NonZeroU32> for u32

type Output = u32

pub fn div(self, other: NonZeroU32) -> u32

This operation rounds towards zero, truncating any fractional part of the exact result, and cannot panic.

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

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

pub fn div(self, other: &f32) -> <f32 as Div<f32>>::Output

impl Div<u8> for u8

This operation rounds towards zero, truncating any fractional part of the exact result.

Panics

This operation will panic if other == 0.

type Output = u8

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

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

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

pub fn div(self, other: &i32) -> <i32 as Div<i32>>::Output

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

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

pub fn div(self, other: &f32) -> <f32 as Div<f32>>::Output

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

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

pub fn div(self, other: f32) -> <f32 as Div<f32>>::Output

impl Div<NonZeroU64> for u64

type Output = u64

pub fn div(self, other: NonZeroU64) -> u64

This operation rounds towards zero, truncating any fractional part of the exact result, and cannot panic.

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

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

pub fn div(self, other: &f64) -> <f64 as Div<f64>>::Output

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

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

pub fn div(self, other: i128) -> <i128 as Div<i128>>::Output

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

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

pub fn div(self, other: i8) -> <i8 as Div<i8>>::Output

impl Div<i64> for i64

This operation rounds towards zero, truncating any fractional part of the exact result.

Panics

This operation will panic if other == 0 or the division results in overflow.

type Output = i64

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

impl Div<NonZeroU8> for u8

type Output = u8

pub fn div(self, other: NonZeroU8) -> u8

This operation rounds towards zero, truncating any fractional part of the exact result, and cannot panic.

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

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

pub fn div(self, other: &isize) -> <isize as Div<isize>>::Output

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

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

pub fn div(self, other: &u64) -> <u64 as Div<u64>>::Output

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

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

pub fn div(self, other: &i64) -> <i64 as Div<i64>>::Output

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

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

pub fn div(self, other: &i128) -> <i128 as Div<i128>>::Output

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

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

pub fn div(self, other: i64) -> <i64 as Div<i64>>::Output

impl Div<i16> for i16

This operation rounds towards zero, truncating any fractional part of the exact result.

Panics

This operation will panic if other == 0 or the division results in overflow.

type Output = i16

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

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

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

pub fn div(self, other: &u16) -> <u16 as Div<u16>>::Output

impl Div<i8> for i8

This operation rounds towards zero, truncating any fractional part of the exact result.

Panics

This operation will panic if other == 0 or the division results in overflow.

type Output = i8

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

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

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

pub fn div(self, other: &u32) -> <u32 as Div<u32>>::Output

impl Div<f64> for f64

type Output = f64

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

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

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

pub fn div(self, other: &i8) -> <i8 as Div<i8>>::Output

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

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

pub fn div(self, other: &usize) -> <usize as Div<usize>>::Output

impl Div<u64> for u64

This operation rounds towards zero, truncating any fractional part of the exact result.

Panics

This operation will panic if other == 0.

type Output = u64

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

impl Div<usize> for usize

This operation rounds towards zero, truncating any fractional part of the exact result.

Panics

This operation will panic if other == 0.

type Output = usize

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

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

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

pub fn div(self, other: i32) -> <i32 as Div<i32>>::Output

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

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

pub fn div(self, other: &u64) -> <u64 as Div<u64>>::Output

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

type Output = ArrayBase<S, D>

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

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

type Output = ArrayBase<S, D>

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

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

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

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

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

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

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

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

type Output = ArrayBase<S, D>

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

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

type Output = ArrayBase<S, D>

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

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

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

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

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

type Output = ArrayBase<S, D>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type Output = ArrayBase<S, D>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type Output = ArrayBase<S, D>

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

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

type Output = ArrayBase<S, D>

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

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

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

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

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

type Output = ArrayBase<S, D>

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

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

type Output = ArrayBase<S, D>

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

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

type Output = ArrayBase<S, D>

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

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

type Output = ArrayBase<S, D>

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

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

type Output = ArrayBase<S, D>

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

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

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

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

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

type Output = ArrayBase<S, D>

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

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

type Output = Complex<isize>

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

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

type Output = Complex<i64>

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

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

type Output = Complex<i8>

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

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

type Output = Complex<u128>

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

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

type Output = Complex<i128>

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

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

type Output = Complex<u8>

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

impl Div<Complex<u8>> for u8

type Output = Complex<u8>

pub fn div(self, other: Complex<u8>) -> <u8 as Div<Complex<u8>>>::Output

impl Div<Complex<u64>> for u64

type Output = Complex<u64>

pub fn div(self, other: Complex<u64>) -> <u64 as Div<Complex<u64>>>::Output

impl Div<Complex<i16>> for i16

type Output = Complex<i16>

pub fn div(self, other: Complex<i16>) -> <i16 as Div<Complex<i16>>>::Output

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

type Output = Complex<i128>

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

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

type Output = Complex<f64>

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

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

type Output = Complex<usize>

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

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

type Output = Complex<i8>

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

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

type Output = Complex<u32>

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

impl Div<Complex<isize>> for isize

type Output = Complex<isize>

pub fn div(
    self,
    other: Complex<isize>
) -> <isize as Div<Complex<isize>>>::Output

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

type Output = Complex<T>

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

impl Div<Complex<f32>> for f32

type Output = Complex<f32>

pub fn div(self, other: Complex<f32>) -> <f32 as Div<Complex<f32>>>::Output

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

type Output = Complex<usize>

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

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

type Output = Complex<T>

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

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

type Output = Complex<u32>

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

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

type Output = Complex<T>

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

impl Div<Complex<i32>> for i32

type Output = Complex<i32>

pub fn div(self, other: Complex<i32>) -> <i32 as Div<Complex<i32>>>::Output

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

type Output = Complex<u64>

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

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

type Output = Complex<T>

pub fn div(self, other: Complex<T>) -> <Complex<T> as Div<Complex<T>>>::Output

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

type Output = Complex<i16>

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

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

type Output = Complex<u128>

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

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

type Output = Complex<i32>

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

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

type Output = Complex<T>

pub fn div(self, other: T) -> <Complex<T> as Div<T>>::Output

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

type Output = Complex<f64>

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

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

type Output = Complex<i64>

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

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

type Output = Complex<u128>

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

impl Div<Complex<u32>> for u32

type Output = Complex<u32>

pub fn div(self, other: Complex<u32>) -> <u32 as Div<Complex<u32>>>::Output

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

type Output = Complex<T>

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

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

type Output = Complex<i32>

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

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

type Output = Complex<i16>

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

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

type Output = Complex<f32>

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

impl Div<Complex<i128>> for i128

type Output = Complex<i128>

pub fn div(self, other: Complex<i128>) -> <i128 as Div<Complex<i128>>>::Output

impl Div<Complex<f64>> for f64

type Output = Complex<f64>

pub fn div(self, other: Complex<f64>) -> <f64 as Div<Complex<f64>>>::Output

impl Div<Complex<u16>> for u16

type Output = Complex<u16>

pub fn div(self, other: Complex<u16>) -> <u16 as Div<Complex<u16>>>::Output

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

type Output = Complex<i128>

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

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

type Output = Complex<isize>

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

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

type Output = Complex<u64>

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

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

type Output = Complex<i32>

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

impl Div<Complex<usize>> for usize

type Output = Complex<usize>

pub fn div(
    self,
    other: Complex<usize>
) -> <usize as Div<Complex<usize>>>::Output

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

type Output = Complex<u32>

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

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

type Output = Complex<f64>

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

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

type Output = Complex<i8>

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

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

type Output = Complex<u8>

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

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

type Output = Complex<i16>

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

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

type Output = Complex<f32>

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

impl Div<Complex<u128>> for u128

type Output = Complex<u128>

pub fn div(self, other: Complex<u128>) -> <u128 as Div<Complex<u128>>>::Output

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

type Output = Complex<u16>

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

impl Div<Complex<i8>> for i8

type Output = Complex<i8>

pub fn div(self, other: Complex<i8>) -> <i8 as Div<Complex<i8>>>::Output

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

type Output = Complex<isize>

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

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

type Output = Complex<u64>

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

impl Div<Complex<i64>> for i64

type Output = Complex<i64>

pub fn div(self, other: Complex<i64>) -> <i64 as Div<Complex<i64>>>::Output

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

type Output = Complex<T>

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

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

type Output = Complex<i64>

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

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

type Output = Complex<u16>

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

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

type Output = Complex<usize>

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

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

type Output = Complex<f32>

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

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

type Output = Complex<u16>

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

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

type Output = Complex<T>

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

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

type Output = Complex<u8>

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

Loading content...

Implementors

impl Div<u32> for Duration

type Output = Duration

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

impl Div<f16> for f16

type Output = f16

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

impl Div<Wrapping<i8>> for Wrapping<i8>

type Output = Wrapping<i8>

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

impl Div<Wrapping<i16>> for Wrapping<i16>

type Output = Wrapping<i16>

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

impl Div<Wrapping<i32>> for Wrapping<i32>

type Output = Wrapping<i32>

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

impl Div<Wrapping<i64>> for Wrapping<i64>

type Output = Wrapping<i64>

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

impl Div<Wrapping<i128>> for Wrapping<i128>

type Output = Wrapping<i128>

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

impl Div<Wrapping<isize>> for Wrapping<isize>

type Output = Wrapping<isize>

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

impl Div<Wrapping<u8>> for Wrapping<u8>

type Output = Wrapping<u8>

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

impl Div<Wrapping<u16>> for Wrapping<u16>

type Output = Wrapping<u16>

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

impl Div<Wrapping<u32>> for Wrapping<u32>

type Output = Wrapping<u32>

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

impl Div<Wrapping<u64>> for Wrapping<u64>

type Output = Wrapping<u64>

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

impl Div<Wrapping<u128>> for Wrapping<u128>

type Output = Wrapping<u128>

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

impl Div<Wrapping<usize>> for Wrapping<usize>

type Output = Wrapping<usize>

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

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

type Output = f16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn div(
    self,
    other: Wrapping<i8>
) -> <Wrapping<i8> as Div<Wrapping<i8>>>::Output

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

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

pub fn div(
    self,
    other: Wrapping<i16>
) -> <Wrapping<i16> as Div<Wrapping<i16>>>::Output

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

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

pub fn div(
    self,
    other: Wrapping<i32>
) -> <Wrapping<i32> as Div<Wrapping<i32>>>::Output

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

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

pub fn div(
    self,
    other: Wrapping<i64>
) -> <Wrapping<i64> as Div<Wrapping<i64>>>::Output

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

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

pub fn div(
    self,
    other: Wrapping<i128>
) -> <Wrapping<i128> as Div<Wrapping<i128>>>::Output

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

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

pub fn div(
    self,
    other: Wrapping<isize>
) -> <Wrapping<isize> as Div<Wrapping<isize>>>::Output

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

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

pub fn div(
    self,
    other: Wrapping<u8>
) -> <Wrapping<u8> as Div<Wrapping<u8>>>::Output

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

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

pub fn div(
    self,
    other: Wrapping<u16>
) -> <Wrapping<u16> as Div<Wrapping<u16>>>::Output

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

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

pub fn div(
    self,
    other: Wrapping<u32>
) -> <Wrapping<u32> as Div<Wrapping<u32>>>::Output

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

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

pub fn div(
    self,
    other: Wrapping<u64>
) -> <Wrapping<u64> as Div<Wrapping<u64>>>::Output

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

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

pub fn div(
    self,
    other: Wrapping<u128>
) -> <Wrapping<u128> as Div<Wrapping<u128>>>::Output

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

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

pub fn div(
    self,
    other: Wrapping<usize>
) -> <Wrapping<usize> as Div<Wrapping<usize>>>::Output

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

Perform elementwise division 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 div(self, rhs: &'a ArrayBase<S2, E>) -> ArrayBase<OwnedRepr<A>, D>

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

Perform elementwise division 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 div(self, rhs: &ArrayBase<S2, E>) -> ArrayBase<S, D>

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

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

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

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

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

Perform elementwise division 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 div(self, rhs: ArrayBase<S2, E>) -> ArrayBase<S, D>

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

Perform elementwise division 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 div(self, x: B) -> ArrayBase<S, D>

impl<I> Div<I> for TDim where
    I: AsPrimitive<u64>, 

type Output = TDim

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

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

type Output = GenericFactoid<T>

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

Loading content...