divrem 1.0.0

Division and modulus variants
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! Division and modulus traits and implementations.
//!
//! There are several definitions for the division and modulus
//! functions, each with different properties.
//! Probably the most common in computer science is truncated division
//! (rounding towards zero) since it is the one provided by most processors
//! and defined as the `/` (and matching `%`) operator in the ISO C99 standard.
//!
//! This crate provides the following definitions:
//!
//! * Floored division (rounding towards negative infinity).
//! * Ceiled division (rounding towards positive infinity).
//! * Euclidean division (sign of modulus is always positive).
//!
//! For every definition, we provide a `Div`, a `Rem` and a `DivRem` variant.
//!
//! A `DivRem` variant of the truncated division is also provided for
//! convenience since it does not exist in the standard library.

#![warn(missing_docs)]
#![warn(rust_2018_idioms)]
#![warn(clippy::pedantic)]
#![warn(clippy::cargo)]
#![warn(clippy::nursery)]
#![deny(unsafe_code)]
#![no_std]

use core::ops::{Div, Rem};

/// Truncated division and remainder.
///
/// Truncates the quotient and effectively rounds towards zero.
/// The sign of the modulus is always the same as the sign of the dividend.
///
/// This is the same as the `/` and `%` operators.
///
/// This is equivalent to the `quotRem` function in Haskell.
pub trait DivRem<RHS = Self>: Div<RHS> + Rem<RHS> {
    /// The resulting type after applying the `/` and `%` operators.
    type Output;

    /// Performs the `/` and `%` operations.
    fn div_rem(self, other: RHS) -> <Self as DivRem<RHS>>::Output;
}

/// Floored division.
///
/// Floors the quotient and effectively rounds towards negative infinity.
///
/// This is equivalent to the `div` function in Haskell.
pub trait DivFloor<RHS = Self>: Div<RHS> {
    /// Performs the floored division operation.
    fn div_floor(self, other: RHS) -> <Self as Div<RHS>>::Output;
}

/// Floored division remainder.
///
/// The sign of the modulus is always the same as the sign of the divisor
/// or zero.
///
/// This is equivalent to the `mod` function in Haskell.
pub trait RemFloor<RHS = Self>: Rem<RHS> {
    /// Returns the remainder of the floored division operation.
    fn rem_floor(self, other: RHS) -> <Self as Rem<RHS>>::Output;
}

/// Floored division and remainder.
///
/// Floors the quotient and effectively rounds towards negative infinity.
/// The sign of the modulus is always the same as the sign of the divisor
/// or zero.
///
/// This is equivalent to the `divMod` function in Haskell.
pub trait DivRemFloor<RHS = Self>: DivRem<RHS> {
    /// Performs the floored division operation with remainder.
    fn div_rem_floor(self, other: RHS) -> <Self as DivRem<RHS>>::Output;
}

/// Euclidean division.
///
/// The sign of the modulus is always positive or zero.
pub trait DivEuclid<RHS = Self>: Div<RHS> {
    /// Performs the euclidean division operation.
    fn div_euclid(self, other: RHS) -> <Self as Div<RHS>>::Output;
}

/// Euclidean remainder.
///
/// The sign of the modulus is always positive or zero.
pub trait RemEuclid<RHS = Self>: Rem<RHS> {
    /// Returns the remainder of the euclidean division operation.
    fn rem_euclid(self, other: RHS) -> <Self as Rem<RHS>>::Output;
}

/// Euclidean division and remainder.
///
/// The sign of the modulus is always positive or zero.
pub trait DivRemEuclid<RHS = Self>: DivRem<RHS> {
    /// Performs the euclidean division operation with remainder.
    fn div_rem_euclid(self, other: RHS) -> <Self as DivRem<RHS>>::Output;
}

/// Ceiled division.
///
/// Ceils the quotient and effectively rounds towards positive infinity.
pub trait DivCeil<RHS = Self>: Div<RHS> {
    /// Performs the ceiled division operation.
    fn div_ceil(self, other: RHS) -> <Self as Div<RHS>>::Output;
}

/// Ceiled division remainder.
///
/// The sign of the modulus is always the opposite of the sign of the divisor
/// or zero.
pub trait RemCeil<RHS = Self>: Rem<RHS> {
    /// Returns the remainder of the ceiled division operation.
    fn rem_ceil(self, other: RHS) -> <Self as Rem<RHS>>::Output;
}

/// Ceiled division and remainder.
///
/// Ceils the quotient and effectively rounds towards positive infinity.
/// The sign of the modulus is always the opposite of the sign of the divisor
/// or zero.
pub trait DivRemCeil<RHS = Self>: DivRem<RHS> {
    /// Performs the ceiled division operation with remainder.
    fn div_rem_ceil(self, other: RHS) -> <Self as DivRem<RHS>>::Output;
}

#[macro_use]
mod macros;
mod ceil;
mod euclid;
mod floor;
mod trunc;