# Trait rocket::mtls::oid::asn1_rs::nom::lib::std::ops::Div

1.0.0 · source · []
``````pub trait Div<Rhs = Self> {
type Output;

fn div(self, rhs: Rhs) -> Self::Output;
}``````
Available on crate feature `mtls` only.
Expand description

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

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, and cannot panic.

#### 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(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(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);``````

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

#### Panics

This operation will panic if `other == 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(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);``````

#### 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);``````

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

#### 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);``````

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

#### Panics

This operation will panic if `other == 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);``````

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.

#### 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);``````

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.

#### 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);``````

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`.

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` 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.

#### 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);``````

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

#### Panics

This operation will panic if `other == 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);``````

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

`Z0 / I = Z0` where `I != 0`

`\$A<Ul> / \$B<Ur> = \$R<Ul / Ur>`

`\$A<Ul> / \$B<Ur> = \$R<Ul / Ur>`

`\$A<Ul> / \$B<Ur> = \$R<Ul / Ur>`

`\$A<Ul> / \$B<Ur> = \$R<Ul / Ur>`