Trait wasmtime_environ::__core::ops::Div

1.0.0 · source · [−]
pub trait Div<Rhs = Self> {
    type Output;
    fn div(self, rhs: Rhs) -> Self::Output;
}
Expand description

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

The resulting type after applying the / operator.

Required methods

Performs the / operation.

Example
assert_eq!(12 / 2, 6);

Implementations on Foreign Types

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

Panics

This operation will panic if other == 0.

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

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

Panics

This operation will panic if other == 0.

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

Panics

This operation will panic if other == 0.

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

Panics

This operation will panic if other == 0.

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.

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

Panics

This operation will panic if other == 0.

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

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.

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.

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

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.

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.

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.

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

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

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

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

Panics

This operation will panic if other == 0.

Implementors

Examples

Basic usage:

#![feature(saturating_int_impl)]
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));
ⓘ
#![feature(saturating_int_impl)]
use std::num::Saturating;

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

Examples

Basic usage:

#![feature(saturating_int_impl)]
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));
ⓘ
#![feature(saturating_int_impl)]
use std::num::Saturating;

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

Examples

Basic usage:

#![feature(saturating_int_impl)]
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));
ⓘ
#![feature(saturating_int_impl)]
use std::num::Saturating;

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

Examples

Basic usage:

#![feature(saturating_int_impl)]
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));
ⓘ
#![feature(saturating_int_impl)]
use std::num::Saturating;

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

Examples

Basic usage:

#![feature(saturating_int_impl)]
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));
ⓘ
#![feature(saturating_int_impl)]
use std::num::Saturating;

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

Examples

Basic usage:

#![feature(saturating_int_impl)]
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));
ⓘ
#![feature(saturating_int_impl)]
use std::num::Saturating;

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

Examples

Basic usage:

#![feature(saturating_int_impl)]
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));
ⓘ
#![feature(saturating_int_impl)]
use std::num::Saturating;

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

Examples

Basic usage:

#![feature(saturating_int_impl)]
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));
ⓘ
#![feature(saturating_int_impl)]
use std::num::Saturating;

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

Examples

Basic usage:

#![feature(saturating_int_impl)]
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));
ⓘ
#![feature(saturating_int_impl)]
use std::num::Saturating;

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

Examples

Basic usage:

#![feature(saturating_int_impl)]
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));
ⓘ
#![feature(saturating_int_impl)]
use std::num::Saturating;

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

Examples

Basic usage:

#![feature(saturating_int_impl)]
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));
ⓘ
#![feature(saturating_int_impl)]
use std::num::Saturating;

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

Examples

Basic usage:

#![feature(saturating_int_impl)]
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));
ⓘ
#![feature(saturating_int_impl)]
use std::num::Saturating;

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