rinia 0.0.16

Stable numeric foundations for graphics, animation, and simulation.
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

/// A trait for saturating addition.
pub trait SaturatingAdd<Rhs = Self> {
    /// The output type for the saturating addition.
    type Output;

    /// Performs saturating addition of `self` and `rhs`.
    fn saturating_add(self, rhs: Rhs) -> Self::Output;
}

/// A trait for saturating subtraction.
pub trait SaturatingSub<Rhs = Self> {
    /// The output type for the saturating subtraction.
    type Output;

    /// Performs saturating subtraction of `self` and `rhs`.
    fn saturating_sub(self, rhs: Rhs) -> Self::Output;
}

/// A trait for saturating multiplication.
pub trait SaturatingMul<Rhs = Self> {
    /// The output type for the saturating multiplication.
    type Output;

    /// Performs saturating multiplication of `self` and `rhs`.
    fn saturating_mul(self, rhs: Rhs) -> Self::Output;
}

/// A trait for saturating division.
pub trait SaturatingDiv<Rhs = Self> {
    /// The output type for the saturating division.
    type Output;

    /// Performs saturating division of `self` and `rhs`.
    fn saturating_div(self, rhs: Rhs) -> Self::Output;
}

/// A trait for saturating negation.
pub trait SaturatingNeg {
    /// The output type for the saturating negation.
    type Output;

    /// Performs saturating negation of `self`.
    fn saturating_neg(self) -> Self::Output;
}

/// A trait for wrapping addition.
pub trait WrappingAdd<Rhs = Self> {
    /// The output type for the wrapping addition.
    type Output;

    /// Performs wrapping addition of `self` and `rhs`.
    fn wrapping_add(self, rhs: Rhs) -> Self::Output;
}

/// A trait for wrapping subtraction.
pub trait WrappingSub<Rhs = Self> {
    /// The output type for the wrapping subtraction.
    type Output;

    /// Performs wrapping subtraction of `self` and `rhs`.
    fn wrapping_sub(self, rhs: Rhs) -> Self::Output;
}

/// A trait for wrapping multiplication.
pub trait WrappingMul<Rhs = Self> {
    /// The output type for the wrapping multiplication.
    type Output;

    /// Performs wrapping multiplication of `self` and `rhs`.
    fn wrapping_mul(self, rhs: Rhs) -> Self::Output;
}

/// A trait for wrapping division.
pub trait WrappingDiv<Rhs = Self> {
    /// The output type for the wrapping division.
    type Output;

    /// Performs wrapping division of `self` and `rhs`.
    fn wrapping_div(self, rhs: Rhs) -> Self::Output;
}

/// A trait for wrapping remainder.
pub trait WrappingRem<Rhs = Self> {
    /// The output type for the wrapping remainder.
    type Output;

    /// Performs wrapping remainder of `self` and `rhs`.
    fn wrapping_rem(self, rhs: Rhs) -> Self::Output;
}

/// A trait for wrapping negation.
pub trait WrappingNeg {
    /// The output type for the wrapping negation.
    type Output;

    /// Performs wrapping negation of `self`.
    fn wrapping_neg(self) -> Self::Output;
}

/// A trait for checked addition.
pub trait CheckedAdd<Rhs = Self> {
    /// The output type for the checked addition.
    type Output;

    /// Performs checked addition of `self` and `rhs`.
    fn checked_add(self, rhs: Rhs) -> Self::Output;
}

/// A trait for checked subtraction.
pub trait CheckedSub<Rhs = Self> {
    /// The output type for the checked subtraction.
    type Output;

    /// Performs checked subtraction of `self` and `rhs`.
    fn checked_sub(self, rhs: Rhs) -> Self::Output;
}

/// A trait for checked multiplication.
pub trait CheckedMul<Rhs = Self> {
    /// The output type for the checked multiplication.
    type Output;

    /// Performs checked multiplication of `self` and `rhs`.
    fn checked_mul(self, rhs: Rhs) -> Self::Output;
}

/// A trait for checked division.
pub trait CheckedDiv<Rhs = Self> {
    /// The output type for the checked division.
    type Output;

    /// Performs checked division of `self` and `rhs`.
    fn checked_div(self, rhs: Rhs) -> Self::Output;
}

/// A trait for checked remainder.
pub trait CheckedRem<Rhs = Self> {
    /// The output type for the checked remainder.
    type Output;

    /// Performs checked remainder of `self` and `rhs`.
    fn checked_rem(self, rhs: Rhs) -> Self::Output;
}

/// A trait for checked negation.
pub trait CheckedNeg {
    /// The output type for the checked negation.
    type Output;

    /// Performs checked negation of `self`.
    fn checked_neg(self) -> Self::Output;
}