Trait malachite_base::num::arithmetic::traits::ArithmeticCheckedShr
source · [−]pub trait ArithmeticCheckedShr<RHS> {
type Output;
fn arithmetic_checked_shr(self, other: RHS) -> Option<Self::Output>;
}
Expand description
Right-shifts a number (divides it by a power of 2), returning None
if the result is not
representable.
Required Associated Types
Required Methods
fn arithmetic_checked_shr(self, other: RHS) -> Option<Self::Output>
Implementations on Foreign Types
sourceimpl ArithmeticCheckedShr<i8> for u8
impl ArithmeticCheckedShr<i8> for u8
sourcefn arithmetic_checked_shr(self, bits: i8) -> Option<u8>
fn arithmetic_checked_shr(self, bits: i8) -> Option<u8>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u8
sourceimpl ArithmeticCheckedShr<i16> for u8
impl ArithmeticCheckedShr<i16> for u8
sourcefn arithmetic_checked_shr(self, bits: i16) -> Option<u8>
fn arithmetic_checked_shr(self, bits: i16) -> Option<u8>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u8
sourceimpl ArithmeticCheckedShr<i32> for u8
impl ArithmeticCheckedShr<i32> for u8
sourcefn arithmetic_checked_shr(self, bits: i32) -> Option<u8>
fn arithmetic_checked_shr(self, bits: i32) -> Option<u8>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u8
sourceimpl ArithmeticCheckedShr<i64> for u8
impl ArithmeticCheckedShr<i64> for u8
sourcefn arithmetic_checked_shr(self, bits: i64) -> Option<u8>
fn arithmetic_checked_shr(self, bits: i64) -> Option<u8>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u8
sourceimpl ArithmeticCheckedShr<i128> for u8
impl ArithmeticCheckedShr<i128> for u8
sourcefn arithmetic_checked_shr(self, bits: i128) -> Option<u8>
fn arithmetic_checked_shr(self, bits: i128) -> Option<u8>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u8
sourceimpl ArithmeticCheckedShr<isize> for u8
impl ArithmeticCheckedShr<isize> for u8
sourcefn arithmetic_checked_shr(self, bits: isize) -> Option<u8>
fn arithmetic_checked_shr(self, bits: isize) -> Option<u8>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u8
sourceimpl ArithmeticCheckedShr<i8> for u16
impl ArithmeticCheckedShr<i8> for u16
sourcefn arithmetic_checked_shr(self, bits: i8) -> Option<u16>
fn arithmetic_checked_shr(self, bits: i8) -> Option<u16>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u16
sourceimpl ArithmeticCheckedShr<i16> for u16
impl ArithmeticCheckedShr<i16> for u16
sourcefn arithmetic_checked_shr(self, bits: i16) -> Option<u16>
fn arithmetic_checked_shr(self, bits: i16) -> Option<u16>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u16
sourceimpl ArithmeticCheckedShr<i32> for u16
impl ArithmeticCheckedShr<i32> for u16
sourcefn arithmetic_checked_shr(self, bits: i32) -> Option<u16>
fn arithmetic_checked_shr(self, bits: i32) -> Option<u16>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u16
sourceimpl ArithmeticCheckedShr<i64> for u16
impl ArithmeticCheckedShr<i64> for u16
sourcefn arithmetic_checked_shr(self, bits: i64) -> Option<u16>
fn arithmetic_checked_shr(self, bits: i64) -> Option<u16>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u16
sourceimpl ArithmeticCheckedShr<i128> for u16
impl ArithmeticCheckedShr<i128> for u16
sourcefn arithmetic_checked_shr(self, bits: i128) -> Option<u16>
fn arithmetic_checked_shr(self, bits: i128) -> Option<u16>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u16
sourceimpl ArithmeticCheckedShr<isize> for u16
impl ArithmeticCheckedShr<isize> for u16
sourcefn arithmetic_checked_shr(self, bits: isize) -> Option<u16>
fn arithmetic_checked_shr(self, bits: isize) -> Option<u16>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u16
sourceimpl ArithmeticCheckedShr<i8> for u32
impl ArithmeticCheckedShr<i8> for u32
sourcefn arithmetic_checked_shr(self, bits: i8) -> Option<u32>
fn arithmetic_checked_shr(self, bits: i8) -> Option<u32>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u32
sourceimpl ArithmeticCheckedShr<i16> for u32
impl ArithmeticCheckedShr<i16> for u32
sourcefn arithmetic_checked_shr(self, bits: i16) -> Option<u32>
fn arithmetic_checked_shr(self, bits: i16) -> Option<u32>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u32
sourceimpl ArithmeticCheckedShr<i32> for u32
impl ArithmeticCheckedShr<i32> for u32
sourcefn arithmetic_checked_shr(self, bits: i32) -> Option<u32>
fn arithmetic_checked_shr(self, bits: i32) -> Option<u32>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u32
sourceimpl ArithmeticCheckedShr<i64> for u32
impl ArithmeticCheckedShr<i64> for u32
sourcefn arithmetic_checked_shr(self, bits: i64) -> Option<u32>
fn arithmetic_checked_shr(self, bits: i64) -> Option<u32>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u32
sourceimpl ArithmeticCheckedShr<i128> for u32
impl ArithmeticCheckedShr<i128> for u32
sourcefn arithmetic_checked_shr(self, bits: i128) -> Option<u32>
fn arithmetic_checked_shr(self, bits: i128) -> Option<u32>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u32
sourceimpl ArithmeticCheckedShr<isize> for u32
impl ArithmeticCheckedShr<isize> for u32
sourcefn arithmetic_checked_shr(self, bits: isize) -> Option<u32>
fn arithmetic_checked_shr(self, bits: isize) -> Option<u32>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u32
sourceimpl ArithmeticCheckedShr<i8> for u64
impl ArithmeticCheckedShr<i8> for u64
sourcefn arithmetic_checked_shr(self, bits: i8) -> Option<u64>
fn arithmetic_checked_shr(self, bits: i8) -> Option<u64>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u64
sourceimpl ArithmeticCheckedShr<i16> for u64
impl ArithmeticCheckedShr<i16> for u64
sourcefn arithmetic_checked_shr(self, bits: i16) -> Option<u64>
fn arithmetic_checked_shr(self, bits: i16) -> Option<u64>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u64
sourceimpl ArithmeticCheckedShr<i32> for u64
impl ArithmeticCheckedShr<i32> for u64
sourcefn arithmetic_checked_shr(self, bits: i32) -> Option<u64>
fn arithmetic_checked_shr(self, bits: i32) -> Option<u64>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u64
sourceimpl ArithmeticCheckedShr<i64> for u64
impl ArithmeticCheckedShr<i64> for u64
sourcefn arithmetic_checked_shr(self, bits: i64) -> Option<u64>
fn arithmetic_checked_shr(self, bits: i64) -> Option<u64>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u64
sourceimpl ArithmeticCheckedShr<i128> for u64
impl ArithmeticCheckedShr<i128> for u64
sourcefn arithmetic_checked_shr(self, bits: i128) -> Option<u64>
fn arithmetic_checked_shr(self, bits: i128) -> Option<u64>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u64
sourceimpl ArithmeticCheckedShr<isize> for u64
impl ArithmeticCheckedShr<isize> for u64
sourcefn arithmetic_checked_shr(self, bits: isize) -> Option<u64>
fn arithmetic_checked_shr(self, bits: isize) -> Option<u64>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u64
sourceimpl ArithmeticCheckedShr<i8> for u128
impl ArithmeticCheckedShr<i8> for u128
sourcefn arithmetic_checked_shr(self, bits: i8) -> Option<u128>
fn arithmetic_checked_shr(self, bits: i8) -> Option<u128>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u128
sourceimpl ArithmeticCheckedShr<i16> for u128
impl ArithmeticCheckedShr<i16> for u128
sourcefn arithmetic_checked_shr(self, bits: i16) -> Option<u128>
fn arithmetic_checked_shr(self, bits: i16) -> Option<u128>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u128
sourceimpl ArithmeticCheckedShr<i32> for u128
impl ArithmeticCheckedShr<i32> for u128
sourcefn arithmetic_checked_shr(self, bits: i32) -> Option<u128>
fn arithmetic_checked_shr(self, bits: i32) -> Option<u128>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u128
sourceimpl ArithmeticCheckedShr<i64> for u128
impl ArithmeticCheckedShr<i64> for u128
sourcefn arithmetic_checked_shr(self, bits: i64) -> Option<u128>
fn arithmetic_checked_shr(self, bits: i64) -> Option<u128>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u128
sourceimpl ArithmeticCheckedShr<i128> for u128
impl ArithmeticCheckedShr<i128> for u128
sourcefn arithmetic_checked_shr(self, bits: i128) -> Option<u128>
fn arithmetic_checked_shr(self, bits: i128) -> Option<u128>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u128
sourceimpl ArithmeticCheckedShr<isize> for u128
impl ArithmeticCheckedShr<isize> for u128
sourcefn arithmetic_checked_shr(self, bits: isize) -> Option<u128>
fn arithmetic_checked_shr(self, bits: isize) -> Option<u128>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u128
sourceimpl ArithmeticCheckedShr<i8> for usize
impl ArithmeticCheckedShr<i8> for usize
sourcefn arithmetic_checked_shr(self, bits: i8) -> Option<usize>
fn arithmetic_checked_shr(self, bits: i8) -> Option<usize>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = usize
sourceimpl ArithmeticCheckedShr<i16> for usize
impl ArithmeticCheckedShr<i16> for usize
sourcefn arithmetic_checked_shr(self, bits: i16) -> Option<usize>
fn arithmetic_checked_shr(self, bits: i16) -> Option<usize>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = usize
sourceimpl ArithmeticCheckedShr<i32> for usize
impl ArithmeticCheckedShr<i32> for usize
sourcefn arithmetic_checked_shr(self, bits: i32) -> Option<usize>
fn arithmetic_checked_shr(self, bits: i32) -> Option<usize>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = usize
sourceimpl ArithmeticCheckedShr<i64> for usize
impl ArithmeticCheckedShr<i64> for usize
sourcefn arithmetic_checked_shr(self, bits: i64) -> Option<usize>
fn arithmetic_checked_shr(self, bits: i64) -> Option<usize>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = usize
sourceimpl ArithmeticCheckedShr<i128> for usize
impl ArithmeticCheckedShr<i128> for usize
sourcefn arithmetic_checked_shr(self, bits: i128) -> Option<usize>
fn arithmetic_checked_shr(self, bits: i128) -> Option<usize>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = usize
sourceimpl ArithmeticCheckedShr<isize> for usize
impl ArithmeticCheckedShr<isize> for usize
sourcefn arithmetic_checked_shr(self, bits: isize) -> Option<usize>
fn arithmetic_checked_shr(self, bits: isize) -> Option<usize>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x < 2^W, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and} \ 2^{-b} x \geq 2^W, \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = usize
sourceimpl ArithmeticCheckedShr<i8> for i8
impl ArithmeticCheckedShr<i8> for i8
sourcefn arithmetic_checked_shr(self, bits: i8) -> Option<i8>
fn arithmetic_checked_shr(self, bits: i8) -> Option<i8>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i8
sourceimpl ArithmeticCheckedShr<i16> for i8
impl ArithmeticCheckedShr<i16> for i8
sourcefn arithmetic_checked_shr(self, bits: i16) -> Option<i8>
fn arithmetic_checked_shr(self, bits: i16) -> Option<i8>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i8
sourceimpl ArithmeticCheckedShr<i32> for i8
impl ArithmeticCheckedShr<i32> for i8
sourcefn arithmetic_checked_shr(self, bits: i32) -> Option<i8>
fn arithmetic_checked_shr(self, bits: i32) -> Option<i8>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i8
sourceimpl ArithmeticCheckedShr<i64> for i8
impl ArithmeticCheckedShr<i64> for i8
sourcefn arithmetic_checked_shr(self, bits: i64) -> Option<i8>
fn arithmetic_checked_shr(self, bits: i64) -> Option<i8>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i8
sourceimpl ArithmeticCheckedShr<i128> for i8
impl ArithmeticCheckedShr<i128> for i8
sourcefn arithmetic_checked_shr(self, bits: i128) -> Option<i8>
fn arithmetic_checked_shr(self, bits: i128) -> Option<i8>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i8
sourceimpl ArithmeticCheckedShr<isize> for i8
impl ArithmeticCheckedShr<isize> for i8
sourcefn arithmetic_checked_shr(self, bits: isize) -> Option<i8>
fn arithmetic_checked_shr(self, bits: isize) -> Option<i8>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i8
sourceimpl ArithmeticCheckedShr<i8> for i16
impl ArithmeticCheckedShr<i8> for i16
sourcefn arithmetic_checked_shr(self, bits: i8) -> Option<i16>
fn arithmetic_checked_shr(self, bits: i8) -> Option<i16>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i16
sourceimpl ArithmeticCheckedShr<i16> for i16
impl ArithmeticCheckedShr<i16> for i16
sourcefn arithmetic_checked_shr(self, bits: i16) -> Option<i16>
fn arithmetic_checked_shr(self, bits: i16) -> Option<i16>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i16
sourceimpl ArithmeticCheckedShr<i32> for i16
impl ArithmeticCheckedShr<i32> for i16
sourcefn arithmetic_checked_shr(self, bits: i32) -> Option<i16>
fn arithmetic_checked_shr(self, bits: i32) -> Option<i16>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i16
sourceimpl ArithmeticCheckedShr<i64> for i16
impl ArithmeticCheckedShr<i64> for i16
sourcefn arithmetic_checked_shr(self, bits: i64) -> Option<i16>
fn arithmetic_checked_shr(self, bits: i64) -> Option<i16>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i16
sourceimpl ArithmeticCheckedShr<i128> for i16
impl ArithmeticCheckedShr<i128> for i16
sourcefn arithmetic_checked_shr(self, bits: i128) -> Option<i16>
fn arithmetic_checked_shr(self, bits: i128) -> Option<i16>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i16
sourceimpl ArithmeticCheckedShr<isize> for i16
impl ArithmeticCheckedShr<isize> for i16
sourcefn arithmetic_checked_shr(self, bits: isize) -> Option<i16>
fn arithmetic_checked_shr(self, bits: isize) -> Option<i16>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i16
sourceimpl ArithmeticCheckedShr<i8> for i32
impl ArithmeticCheckedShr<i8> for i32
sourcefn arithmetic_checked_shr(self, bits: i8) -> Option<i32>
fn arithmetic_checked_shr(self, bits: i8) -> Option<i32>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i32
sourceimpl ArithmeticCheckedShr<i16> for i32
impl ArithmeticCheckedShr<i16> for i32
sourcefn arithmetic_checked_shr(self, bits: i16) -> Option<i32>
fn arithmetic_checked_shr(self, bits: i16) -> Option<i32>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i32
sourceimpl ArithmeticCheckedShr<i32> for i32
impl ArithmeticCheckedShr<i32> for i32
sourcefn arithmetic_checked_shr(self, bits: i32) -> Option<i32>
fn arithmetic_checked_shr(self, bits: i32) -> Option<i32>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i32
sourceimpl ArithmeticCheckedShr<i64> for i32
impl ArithmeticCheckedShr<i64> for i32
sourcefn arithmetic_checked_shr(self, bits: i64) -> Option<i32>
fn arithmetic_checked_shr(self, bits: i64) -> Option<i32>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i32
sourceimpl ArithmeticCheckedShr<i128> for i32
impl ArithmeticCheckedShr<i128> for i32
sourcefn arithmetic_checked_shr(self, bits: i128) -> Option<i32>
fn arithmetic_checked_shr(self, bits: i128) -> Option<i32>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i32
sourceimpl ArithmeticCheckedShr<isize> for i32
impl ArithmeticCheckedShr<isize> for i32
sourcefn arithmetic_checked_shr(self, bits: isize) -> Option<i32>
fn arithmetic_checked_shr(self, bits: isize) -> Option<i32>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i32
sourceimpl ArithmeticCheckedShr<i8> for i64
impl ArithmeticCheckedShr<i8> for i64
sourcefn arithmetic_checked_shr(self, bits: i8) -> Option<i64>
fn arithmetic_checked_shr(self, bits: i8) -> Option<i64>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i64
sourceimpl ArithmeticCheckedShr<i16> for i64
impl ArithmeticCheckedShr<i16> for i64
sourcefn arithmetic_checked_shr(self, bits: i16) -> Option<i64>
fn arithmetic_checked_shr(self, bits: i16) -> Option<i64>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i64
sourceimpl ArithmeticCheckedShr<i32> for i64
impl ArithmeticCheckedShr<i32> for i64
sourcefn arithmetic_checked_shr(self, bits: i32) -> Option<i64>
fn arithmetic_checked_shr(self, bits: i32) -> Option<i64>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i64
sourceimpl ArithmeticCheckedShr<i64> for i64
impl ArithmeticCheckedShr<i64> for i64
sourcefn arithmetic_checked_shr(self, bits: i64) -> Option<i64>
fn arithmetic_checked_shr(self, bits: i64) -> Option<i64>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i64
sourceimpl ArithmeticCheckedShr<i128> for i64
impl ArithmeticCheckedShr<i128> for i64
sourcefn arithmetic_checked_shr(self, bits: i128) -> Option<i64>
fn arithmetic_checked_shr(self, bits: i128) -> Option<i64>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i64
sourceimpl ArithmeticCheckedShr<isize> for i64
impl ArithmeticCheckedShr<isize> for i64
sourcefn arithmetic_checked_shr(self, bits: isize) -> Option<i64>
fn arithmetic_checked_shr(self, bits: isize) -> Option<i64>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i64
sourceimpl ArithmeticCheckedShr<i8> for i128
impl ArithmeticCheckedShr<i8> for i128
sourcefn arithmetic_checked_shr(self, bits: i8) -> Option<i128>
fn arithmetic_checked_shr(self, bits: i8) -> Option<i128>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i128
sourceimpl ArithmeticCheckedShr<i16> for i128
impl ArithmeticCheckedShr<i16> for i128
sourcefn arithmetic_checked_shr(self, bits: i16) -> Option<i128>
fn arithmetic_checked_shr(self, bits: i16) -> Option<i128>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i128
sourceimpl ArithmeticCheckedShr<i32> for i128
impl ArithmeticCheckedShr<i32> for i128
sourcefn arithmetic_checked_shr(self, bits: i32) -> Option<i128>
fn arithmetic_checked_shr(self, bits: i32) -> Option<i128>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i128
sourceimpl ArithmeticCheckedShr<i64> for i128
impl ArithmeticCheckedShr<i64> for i128
sourcefn arithmetic_checked_shr(self, bits: i64) -> Option<i128>
fn arithmetic_checked_shr(self, bits: i64) -> Option<i128>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i128
sourceimpl ArithmeticCheckedShr<i128> for i128
impl ArithmeticCheckedShr<i128> for i128
sourcefn arithmetic_checked_shr(self, bits: i128) -> Option<i128>
fn arithmetic_checked_shr(self, bits: i128) -> Option<i128>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i128
sourceimpl ArithmeticCheckedShr<isize> for i128
impl ArithmeticCheckedShr<isize> for i128
sourcefn arithmetic_checked_shr(self, bits: isize) -> Option<i128>
fn arithmetic_checked_shr(self, bits: isize) -> Option<i128>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i128
sourceimpl ArithmeticCheckedShr<i8> for isize
impl ArithmeticCheckedShr<i8> for isize
sourcefn arithmetic_checked_shr(self, bits: i8) -> Option<isize>
fn arithmetic_checked_shr(self, bits: i8) -> Option<isize>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = isize
sourceimpl ArithmeticCheckedShr<i16> for isize
impl ArithmeticCheckedShr<i16> for isize
sourcefn arithmetic_checked_shr(self, bits: i16) -> Option<isize>
fn arithmetic_checked_shr(self, bits: i16) -> Option<isize>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = isize
sourceimpl ArithmeticCheckedShr<i32> for isize
impl ArithmeticCheckedShr<i32> for isize
sourcefn arithmetic_checked_shr(self, bits: i32) -> Option<isize>
fn arithmetic_checked_shr(self, bits: i32) -> Option<isize>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = isize
sourceimpl ArithmeticCheckedShr<i64> for isize
impl ArithmeticCheckedShr<i64> for isize
sourcefn arithmetic_checked_shr(self, bits: i64) -> Option<isize>
fn arithmetic_checked_shr(self, bits: i64) -> Option<isize>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = isize
sourceimpl ArithmeticCheckedShr<i128> for isize
impl ArithmeticCheckedShr<i128> for isize
sourcefn arithmetic_checked_shr(self, bits: i128) -> Option<isize>
fn arithmetic_checked_shr(self, bits: i128) -> Option<isize>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = isize
sourceimpl ArithmeticCheckedShr<isize> for isize
impl ArithmeticCheckedShr<isize> for isize
sourcefn arithmetic_checked_shr(self, bits: isize) -> Option<isize>
fn arithmetic_checked_shr(self, bits: isize) -> Option<isize>
Shifts a number right (divides it by a power of 2). If the result is too
large to be represented, None
is returned.
Zero may be shifted by any amount, and any number may be shifted by any non-
negative amount; shifting by a large amount returns Some(0)
if self
is
positive, and Some(-1)
if self
is negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(\lfloor x/2^b \rfloor) &
\text{if} \quad b \geq 0, \\
\operatorname{Some}(2^{-b} x) &
\text{if} \quad b < 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^{-b} x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b < 0 \ \mathrm{and}
\ (2^{-b} x < -2^{W-1} \ \mathrm{or}
\ 2^{-b} x \geq 2^{W-1}), \\
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.