Trait std::ops::Div

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

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

The division operator /.

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

Examples

`Div`idable 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] });

Required Associated Types

source

type Output

The resulting type after applying the / operator.

Required Methods

source

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

Performs the / operation.

Example

assert_eq!(12 / 2, 6);

Implementors

source

impl Div for f32

type Output = f32

source

impl Div for f64

type Output = f64

source

impl Div 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

source

impl Div 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

source

impl Div 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

source

impl Div 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

source

impl Div 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

source

impl Div 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

source

impl Div 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

source

impl Div 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

source

impl Div 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

source

impl Div 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

source

impl Div 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

source

impl Div 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

1.74.0source

impl Div for Saturating<i8>

Examples

Basic usage:

use std::num::Saturating;

assert_eq!(Saturating(2i8), Saturating(5i8) / Saturating(2));
assert_eq!(Saturating(i8::MAX), Saturating(i8::MAX) / Saturating(1));
assert_eq!(Saturating(i8::MIN), Saturating(i8::MIN) / Saturating(1));

ⓘ

use std::num::Saturating;

let _ = Saturating(0i8) / Saturating(0);

type Output = Saturating<i8>

1.74.0source

impl Div for Saturating<i16>

Examples

Basic usage:

use std::num::Saturating;

assert_eq!(Saturating(2i16), Saturating(5i16) / Saturating(2));
assert_eq!(Saturating(i16::MAX), Saturating(i16::MAX) / Saturating(1));
assert_eq!(Saturating(i16::MIN), Saturating(i16::MIN) / Saturating(1));

ⓘ

use std::num::Saturating;

let _ = Saturating(0i16) / Saturating(0);

type Output = Saturating<i16>

1.74.0source

impl Div for Saturating<i32>

Examples

Basic usage:

use std::num::Saturating;

assert_eq!(Saturating(2i32), Saturating(5i32) / Saturating(2));
assert_eq!(Saturating(i32::MAX), Saturating(i32::MAX) / Saturating(1));
assert_eq!(Saturating(i32::MIN), Saturating(i32::MIN) / Saturating(1));

ⓘ

use std::num::Saturating;

let _ = Saturating(0i32) / Saturating(0);

type Output = Saturating<i32>

1.74.0source

impl Div for Saturating<i64>

Examples

Basic usage:

use std::num::Saturating;

assert_eq!(Saturating(2i64), Saturating(5i64) / Saturating(2));
assert_eq!(Saturating(i64::MAX), Saturating(i64::MAX) / Saturating(1));
assert_eq!(Saturating(i64::MIN), Saturating(i64::MIN) / Saturating(1));

ⓘ

use std::num::Saturating;

let _ = Saturating(0i64) / Saturating(0);

type Output = Saturating<i64>

1.74.0source

impl Div for Saturating<i128>

Examples

Basic usage:

use std::num::Saturating;

assert_eq!(Saturating(2i128), Saturating(5i128) / Saturating(2));
assert_eq!(Saturating(i128::MAX), Saturating(i128::MAX) / Saturating(1));
assert_eq!(Saturating(i128::MIN), Saturating(i128::MIN) / Saturating(1));

ⓘ

use std::num::Saturating;

let _ = Saturating(0i128) / Saturating(0);

type Output = Saturating<i128>

1.74.0source

impl Div for Saturating<isize>

Examples

Basic usage:

use std::num::Saturating;

assert_eq!(Saturating(2isize), Saturating(5isize) / Saturating(2));
assert_eq!(Saturating(isize::MAX), Saturating(isize::MAX) / Saturating(1));
assert_eq!(Saturating(isize::MIN), Saturating(isize::MIN) / Saturating(1));

ⓘ

use std::num::Saturating;

let _ = Saturating(0isize) / Saturating(0);

type Output = Saturating<isize>

1.74.0source

impl Div for Saturating<u8>

Examples

Basic usage:

use std::num::Saturating;

assert_eq!(Saturating(2u8), Saturating(5u8) / Saturating(2));
assert_eq!(Saturating(u8::MAX), Saturating(u8::MAX) / Saturating(1));
assert_eq!(Saturating(u8::MIN), Saturating(u8::MIN) / Saturating(1));

ⓘ

use std::num::Saturating;

let _ = Saturating(0u8) / Saturating(0);

type Output = Saturating<u8>

1.74.0source

impl Div for Saturating<u16>

Examples

Basic usage:

use std::num::Saturating;

assert_eq!(Saturating(2u16), Saturating(5u16) / Saturating(2));
assert_eq!(Saturating(u16::MAX), Saturating(u16::MAX) / Saturating(1));
assert_eq!(Saturating(u16::MIN), Saturating(u16::MIN) / Saturating(1));

ⓘ

use std::num::Saturating;

let _ = Saturating(0u16) / Saturating(0);

type Output = Saturating<u16>

1.74.0source

impl Div for Saturating<u32>

Examples

Basic usage:

use std::num::Saturating;

assert_eq!(Saturating(2u32), Saturating(5u32) / Saturating(2));
assert_eq!(Saturating(u32::MAX), Saturating(u32::MAX) / Saturating(1));
assert_eq!(Saturating(u32::MIN), Saturating(u32::MIN) / Saturating(1));

ⓘ

use std::num::Saturating;

let _ = Saturating(0u32) / Saturating(0);

type Output = Saturating<u32>

1.74.0source

impl Div for Saturating<u64>

Examples

Basic usage:

use std::num::Saturating;

assert_eq!(Saturating(2u64), Saturating(5u64) / Saturating(2));
assert_eq!(Saturating(u64::MAX), Saturating(u64::MAX) / Saturating(1));
assert_eq!(Saturating(u64::MIN), Saturating(u64::MIN) / Saturating(1));

ⓘ

use std::num::Saturating;

let _ = Saturating(0u64) / Saturating(0);

type Output = Saturating<u64>

1.74.0source

impl Div for Saturating<u128>

Examples

Basic usage:

use std::num::Saturating;

assert_eq!(Saturating(2u128), Saturating(5u128) / Saturating(2));
assert_eq!(Saturating(u128::MAX), Saturating(u128::MAX) / Saturating(1));
assert_eq!(Saturating(u128::MIN), Saturating(u128::MIN) / Saturating(1));

ⓘ

use std::num::Saturating;

let _ = Saturating(0u128) / Saturating(0);

type Output = Saturating<u128>

1.74.0source

impl Div for Saturating<usize>

Examples

Basic usage:

use std::num::Saturating;

assert_eq!(Saturating(2usize), Saturating(5usize) / Saturating(2));
assert_eq!(Saturating(usize::MAX), Saturating(usize::MAX) / Saturating(1));
assert_eq!(Saturating(usize::MIN), Saturating(usize::MIN) / Saturating(1));

ⓘ

use std::num::Saturating;

let _ = Saturating(0usize) / Saturating(0);

type Output = Saturating<usize>

1.3.0source

impl Div for Wrapping<i8>

type Output = Wrapping<i8>

1.3.0source

impl Div for Wrapping<i16>

type Output = Wrapping<i16>

1.3.0source

impl Div for Wrapping<i32>

type Output = Wrapping<i32>

1.3.0source

impl Div for Wrapping<i64>

type Output = Wrapping<i64>

1.3.0source

impl Div for Wrapping<i128>

type Output = Wrapping<i128>

1.3.0source

impl Div for Wrapping<isize>

type Output = Wrapping<isize>

1.3.0source

impl Div for Wrapping<u8>

type Output = Wrapping<u8>

1.3.0source

impl Div for Wrapping<u16>

type Output = Wrapping<u16>

1.3.0source

impl Div for Wrapping<u32>

type Output = Wrapping<u32>

1.3.0source

impl Div for Wrapping<u64>

type Output = Wrapping<u64>

1.3.0source

impl Div for Wrapping<u128>

type Output = Wrapping<u128>

1.3.0source

impl Div for Wrapping<usize>

type Output = Wrapping<usize>

source

impl Div<&f32> for &f32

type Output = <f32 as Div>::Output

source

impl Div<&f32> for f32

type Output = <f32 as Div>::Output

source

impl Div<&f64> for &f64

type Output = <f64 as Div>::Output

source

impl Div<&f64> for f64

type Output = <f64 as Div>::Output

source

impl Div<&i8> for &i8

type Output = <i8 as Div>::Output

source

impl Div<&i8> for i8

type Output = <i8 as Div>::Output

source

impl Div<&i16> for &i16

type Output = <i16 as Div>::Output

source

impl Div<&i16> for i16

type Output = <i16 as Div>::Output

source

impl Div<&i32> for &i32

type Output = <i32 as Div>::Output

source

impl Div<&i32> for i32

type Output = <i32 as Div>::Output

source

impl Div<&i64> for &i64

type Output = <i64 as Div>::Output

source

impl Div<&i64> for i64

type Output = <i64 as Div>::Output

source

impl Div<&i128> for &i128

type Output = <i128 as Div>::Output

source

impl Div<&i128> for i128

type Output = <i128 as Div>::Output

source

impl Div<&isize> for &isize

type Output = <isize as Div>::Output

source

impl Div<&isize> for isize

type Output = <isize as Div>::Output

source

impl Div<&u8> for &u8

type Output = <u8 as Div>::Output

source

impl Div<&u8> for u8

type Output = <u8 as Div>::Output

source

impl Div<&u16> for &u16

type Output = <u16 as Div>::Output

source

impl Div<&u16> for u16

type Output = <u16 as Div>::Output

source

impl Div<&u32> for &u32

type Output = <u32 as Div>::Output

source

impl Div<&u32> for u32

type Output = <u32 as Div>::Output

source

impl Div<&u64> for &u64

type Output = <u64 as Div>::Output

source

impl Div<&u64> for u64

type Output = <u64 as Div>::Output

source

impl Div<&u128> for &u128

type Output = <u128 as Div>::Output

source

impl Div<&u128> for u128

type Output = <u128 as Div>::Output

source

impl Div<&usize> for &usize

type Output = <usize as Div>::Output

source

impl Div<&usize> for usize

type Output = <usize as Div>::Output

1.74.0source

impl Div<&Saturating<i8>> for &Saturating<i8>

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

1.74.0source

impl Div<&Saturating<i8>> for Saturating<i8>

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

1.74.0source

impl Div<&Saturating<i16>> for &Saturating<i16>

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

1.74.0source

impl Div<&Saturating<i16>> for Saturating<i16>

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

1.74.0source

impl Div<&Saturating<i32>> for &Saturating<i32>

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

1.74.0source

impl Div<&Saturating<i32>> for Saturating<i32>

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

1.74.0source

impl Div<&Saturating<i64>> for &Saturating<i64>

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

1.74.0source

impl Div<&Saturating<i64>> for Saturating<i64>

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

1.74.0source

impl Div<&Saturating<i128>> for &Saturating<i128>

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

1.74.0source

impl Div<&Saturating<i128>> for Saturating<i128>

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

1.74.0source

impl Div<&Saturating<isize>> for &Saturating<isize>

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

1.74.0source

impl Div<&Saturating<isize>> for Saturating<isize>

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

1.74.0source

impl Div<&Saturating<u8>> for &Saturating<u8>

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

1.74.0source

impl Div<&Saturating<u8>> for Saturating<u8>

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

1.74.0source

impl Div<&Saturating<u16>> for &Saturating<u16>

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

1.74.0source

impl Div<&Saturating<u16>> for Saturating<u16>

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

1.74.0source

impl Div<&Saturating<u32>> for &Saturating<u32>

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

1.74.0source

impl Div<&Saturating<u32>> for Saturating<u32>

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

1.74.0source

impl Div<&Saturating<u64>> for &Saturating<u64>

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

1.74.0source

impl Div<&Saturating<u64>> for Saturating<u64>

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

1.74.0source

impl Div<&Saturating<u128>> for &Saturating<u128>

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

1.74.0source

impl Div<&Saturating<u128>> for Saturating<u128>

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

1.74.0source

impl Div<&Saturating<usize>> for &Saturating<usize>

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

1.74.0source

impl Div<&Saturating<usize>> for Saturating<usize>

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.3.0source

impl Div<u32> for Duration

type Output = Duration

1.51.0source

impl Div<NonZeroU8> for u8

type Output = u8

1.51.0source

impl Div<NonZeroU16> for u16

type Output = u16

1.51.0source

impl Div<NonZeroU32> for u32

type Output = u32

1.51.0source

impl Div<NonZeroU64> for u64

type Output = u64

1.51.0source

impl Div<NonZeroU128> for u128

type Output = u128

1.51.0source

impl Div<NonZeroUsize> for usize

type Output = usize

source

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

type Output = <f32 as Div>::Output

source

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

type Output = <f64 as Div>::Output

source

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

type Output = <i8 as Div>::Output

source

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

type Output = <i16 as Div>::Output

source

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

type Output = <i32 as Div>::Output

source

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

type Output = <i64 as Div>::Output

source

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

type Output = <i128 as Div>::Output

source

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

type Output = <isize as Div>::Output

source

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

type Output = <u8 as Div>::Output

source

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

type Output = <u16 as Div>::Output

source

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

type Output = <u32 as Div>::Output

source

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

type Output = <u64 as Div>::Output

source

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

type Output = <u128 as Div>::Output

source

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

type Output = <usize as Div>::Output

1.74.0source

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

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

1.74.0source

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

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

1.74.0source

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

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

1.74.0source

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

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

1.74.0source

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

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

1.74.0source

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

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

1.74.0source

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

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

1.74.0source

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

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

1.74.0source

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

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

1.74.0source

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

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

1.74.0source

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

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

1.74.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

1.14.0source

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

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

source

impl<'lhs, 'rhs, T, const LANES: usize> Div<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>
where
    T: SimdElement,
    Simd<T, LANES>: Div<Output = Simd<T, LANES>>,
    LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

source

impl<T, const LANES: usize> Div<&Simd<T, LANES>> for Simd<T, LANES>
where
    T: SimdElement,
    Simd<T, LANES>: Div<Output = Simd<T, LANES>>,
    LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

source

impl<T, const LANES: usize> Div<Simd<T, LANES>> for &Simd<T, LANES>
where
    T: SimdElement,
    Simd<T, LANES>: Div<Output = Simd<T, LANES>>,
    LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

source

impl<const N: usize> Div for Simd<f32, N>
where
    f32: SimdElement,
    LaneCount<N>: SupportedLaneCount,

type Output = Simd<f32, N>

source

impl<const N: usize> Div for Simd<f64, N>
where
    f64: SimdElement,
    LaneCount<N>: SupportedLaneCount,

type Output = Simd<f64, N>

source

impl<const N: usize> Div for Simd<i8, N>
where
    i8: SimdElement,
    LaneCount<N>: SupportedLaneCount,

type Output = Simd<i8, N>

source

impl<const N: usize> Div for Simd<i16, N>
where
    i16: SimdElement,
    LaneCount<N>: SupportedLaneCount,

type Output = Simd<i16, N>

source

impl<const N: usize> Div for Simd<i32, N>
where
    i32: SimdElement,
    LaneCount<N>: SupportedLaneCount,

type Output = Simd<i32, N>

source

impl<const N: usize> Div for Simd<i64, N>
where
    i64: SimdElement,
    LaneCount<N>: SupportedLaneCount,

type Output = Simd<i64, N>

source

impl<const N: usize> Div for Simd<isize, N>
where
    isize: SimdElement,
    LaneCount<N>: SupportedLaneCount,

type Output = Simd<isize, N>

source

impl<const N: usize> Div for Simd<u8, N>
where
    u8: SimdElement,
    LaneCount<N>: SupportedLaneCount,

type Output = Simd<u8, N>

source

impl<const N: usize> Div for Simd<u16, N>
where
    u16: SimdElement,
    LaneCount<N>: SupportedLaneCount,

type Output = Simd<u16, N>

source

impl<const N: usize> Div for Simd<u32, N>
where
    u32: SimdElement,
    LaneCount<N>: SupportedLaneCount,

type Output = Simd<u32, N>

source

impl<const N: usize> Div for Simd<u64, N>
where
    u64: SimdElement,
    LaneCount<N>: SupportedLaneCount,

type Output = Simd<u64, N>

source

impl<const N: usize> Div for Simd<usize, N>
where
    usize: SimdElement,
    LaneCount<N>: SupportedLaneCount,

type Output = Simd<usize, N>

© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/ops/trait.Div.html

Docs

Docs4dev

Title here

Trait std::ops::Div

Examples

`Div`idable rational numbers

Dividing vectors by scalars as in linear algebra

Required Associated Types

Required Methods

Example

Implementors

Panics

Panics

Panics

Panics

Panics

Panics

Panics

Panics

Panics

Panics

Panics

Panics

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Trait std::ops::Div

Examples

Dividable rational numbers

Dividing vectors by scalars as in linear algebra

Required Associated Types

Required Methods

Example

Implementors

Panics

Panics

Panics

Panics

Panics

Panics

Panics

Panics

Panics

Panics

Panics

Panics

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Examples

`Div`idable rational numbers