Trait malachite_base::num::arithmetic::traits::ArithmeticCheckedShl
source · [−]pub trait ArithmeticCheckedShl<RHS> {
type Output;
fn arithmetic_checked_shl(self, other: RHS) -> Option<Self::Output>;
}
Expand description
Left-shifts a number (multiplies it by a power of 2), returning None
if the result is not
representable.
Required Associated Types
Required Methods
fn arithmetic_checked_shl(self, other: RHS) -> Option<Self::Output>
Implementations on Foreign Types
sourceimpl ArithmeticCheckedShl<u8> for u8
impl ArithmeticCheckedShl<u8> for u8
sourcefn arithmetic_checked_shl(self, bits: u8) -> Option<u8>
fn arithmetic_checked_shl(self, bits: u8) -> Option<u8>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u16> for u8
impl ArithmeticCheckedShl<u16> for u8
sourcefn arithmetic_checked_shl(self, bits: u16) -> Option<u8>
fn arithmetic_checked_shl(self, bits: u16) -> Option<u8>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u32> for u8
impl ArithmeticCheckedShl<u32> for u8
sourcefn arithmetic_checked_shl(self, bits: u32) -> Option<u8>
fn arithmetic_checked_shl(self, bits: u32) -> Option<u8>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u64> for u8
impl ArithmeticCheckedShl<u64> for u8
sourcefn arithmetic_checked_shl(self, bits: u64) -> Option<u8>
fn arithmetic_checked_shl(self, bits: u64) -> Option<u8>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u128> for u8
impl ArithmeticCheckedShl<u128> for u8
sourcefn arithmetic_checked_shl(self, bits: u128) -> Option<u8>
fn arithmetic_checked_shl(self, bits: u128) -> Option<u8>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<usize> for u8
impl ArithmeticCheckedShl<usize> for u8
sourcefn arithmetic_checked_shl(self, bits: usize) -> Option<u8>
fn arithmetic_checked_shl(self, bits: usize) -> Option<u8>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u8> for u16
impl ArithmeticCheckedShl<u8> for u16
sourcefn arithmetic_checked_shl(self, bits: u8) -> Option<u16>
fn arithmetic_checked_shl(self, bits: u8) -> Option<u16>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u16> for u16
impl ArithmeticCheckedShl<u16> for u16
sourcefn arithmetic_checked_shl(self, bits: u16) -> Option<u16>
fn arithmetic_checked_shl(self, bits: u16) -> Option<u16>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u32> for u16
impl ArithmeticCheckedShl<u32> for u16
sourcefn arithmetic_checked_shl(self, bits: u32) -> Option<u16>
fn arithmetic_checked_shl(self, bits: u32) -> Option<u16>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u64> for u16
impl ArithmeticCheckedShl<u64> for u16
sourcefn arithmetic_checked_shl(self, bits: u64) -> Option<u16>
fn arithmetic_checked_shl(self, bits: u64) -> Option<u16>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u128> for u16
impl ArithmeticCheckedShl<u128> for u16
sourcefn arithmetic_checked_shl(self, bits: u128) -> Option<u16>
fn arithmetic_checked_shl(self, bits: u128) -> Option<u16>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<usize> for u16
impl ArithmeticCheckedShl<usize> for u16
sourcefn arithmetic_checked_shl(self, bits: usize) -> Option<u16>
fn arithmetic_checked_shl(self, bits: usize) -> Option<u16>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u8> for u32
impl ArithmeticCheckedShl<u8> for u32
sourcefn arithmetic_checked_shl(self, bits: u8) -> Option<u32>
fn arithmetic_checked_shl(self, bits: u8) -> Option<u32>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u16> for u32
impl ArithmeticCheckedShl<u16> for u32
sourcefn arithmetic_checked_shl(self, bits: u16) -> Option<u32>
fn arithmetic_checked_shl(self, bits: u16) -> Option<u32>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u32> for u32
impl ArithmeticCheckedShl<u32> for u32
sourcefn arithmetic_checked_shl(self, bits: u32) -> Option<u32>
fn arithmetic_checked_shl(self, bits: u32) -> Option<u32>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u64> for u32
impl ArithmeticCheckedShl<u64> for u32
sourcefn arithmetic_checked_shl(self, bits: u64) -> Option<u32>
fn arithmetic_checked_shl(self, bits: u64) -> Option<u32>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u128> for u32
impl ArithmeticCheckedShl<u128> for u32
sourcefn arithmetic_checked_shl(self, bits: u128) -> Option<u32>
fn arithmetic_checked_shl(self, bits: u128) -> Option<u32>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<usize> for u32
impl ArithmeticCheckedShl<usize> for u32
sourcefn arithmetic_checked_shl(self, bits: usize) -> Option<u32>
fn arithmetic_checked_shl(self, bits: usize) -> Option<u32>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u8> for u64
impl ArithmeticCheckedShl<u8> for u64
sourcefn arithmetic_checked_shl(self, bits: u8) -> Option<u64>
fn arithmetic_checked_shl(self, bits: u8) -> Option<u64>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u16> for u64
impl ArithmeticCheckedShl<u16> for u64
sourcefn arithmetic_checked_shl(self, bits: u16) -> Option<u64>
fn arithmetic_checked_shl(self, bits: u16) -> Option<u64>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u32> for u64
impl ArithmeticCheckedShl<u32> for u64
sourcefn arithmetic_checked_shl(self, bits: u32) -> Option<u64>
fn arithmetic_checked_shl(self, bits: u32) -> Option<u64>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u64> for u64
impl ArithmeticCheckedShl<u64> for u64
sourcefn arithmetic_checked_shl(self, bits: u64) -> Option<u64>
fn arithmetic_checked_shl(self, bits: u64) -> Option<u64>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u128> for u64
impl ArithmeticCheckedShl<u128> for u64
sourcefn arithmetic_checked_shl(self, bits: u128) -> Option<u64>
fn arithmetic_checked_shl(self, bits: u128) -> Option<u64>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<usize> for u64
impl ArithmeticCheckedShl<usize> for u64
sourcefn arithmetic_checked_shl(self, bits: usize) -> Option<u64>
fn arithmetic_checked_shl(self, bits: usize) -> Option<u64>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u8> for u128
impl ArithmeticCheckedShl<u8> for u128
sourcefn arithmetic_checked_shl(self, bits: u8) -> Option<u128>
fn arithmetic_checked_shl(self, bits: u8) -> Option<u128>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u16> for u128
impl ArithmeticCheckedShl<u16> for u128
sourcefn arithmetic_checked_shl(self, bits: u16) -> Option<u128>
fn arithmetic_checked_shl(self, bits: u16) -> Option<u128>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u32> for u128
impl ArithmeticCheckedShl<u32> for u128
sourcefn arithmetic_checked_shl(self, bits: u32) -> Option<u128>
fn arithmetic_checked_shl(self, bits: u32) -> Option<u128>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u64> for u128
impl ArithmeticCheckedShl<u64> for u128
sourcefn arithmetic_checked_shl(self, bits: u64) -> Option<u128>
fn arithmetic_checked_shl(self, bits: u64) -> Option<u128>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u128> for u128
impl ArithmeticCheckedShl<u128> for u128
sourcefn arithmetic_checked_shl(self, bits: u128) -> Option<u128>
fn arithmetic_checked_shl(self, bits: u128) -> Option<u128>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<usize> for u128
impl ArithmeticCheckedShl<usize> for u128
sourcefn arithmetic_checked_shl(self, bits: usize) -> Option<u128>
fn arithmetic_checked_shl(self, bits: usize) -> Option<u128>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u8> for usize
impl ArithmeticCheckedShl<u8> for usize
sourcefn arithmetic_checked_shl(self, bits: u8) -> Option<usize>
fn arithmetic_checked_shl(self, bits: u8) -> Option<usize>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u16> for usize
impl ArithmeticCheckedShl<u16> for usize
sourcefn arithmetic_checked_shl(self, bits: u16) -> Option<usize>
fn arithmetic_checked_shl(self, bits: u16) -> Option<usize>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u32> for usize
impl ArithmeticCheckedShl<u32> for usize
sourcefn arithmetic_checked_shl(self, bits: u32) -> Option<usize>
fn arithmetic_checked_shl(self, bits: u32) -> Option<usize>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u64> for usize
impl ArithmeticCheckedShl<u64> for usize
sourcefn arithmetic_checked_shl(self, bits: u64) -> Option<usize>
fn arithmetic_checked_shl(self, bits: u64) -> Option<usize>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<u128> for usize
impl ArithmeticCheckedShl<u128> for usize
sourcefn arithmetic_checked_shl(self, bits: u128) -> Option<usize>
fn arithmetic_checked_shl(self, bits: u128) -> Option<usize>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<usize> for usize
impl ArithmeticCheckedShl<usize> for usize
sourcefn arithmetic_checked_shl(self, bits: usize) -> Option<usize>
fn arithmetic_checked_shl(self, bits: usize) -> Option<usize>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) & \text{if} \quad 2^b x < 2^W, \\
\operatorname{None} & \text{if} \quad 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 ArithmeticCheckedShl<i8> for u8
impl ArithmeticCheckedShl<i8> for u8
sourcefn arithmetic_checked_shl(self, bits: i8) -> Option<u8>
fn arithmetic_checked_shl(self, bits: i8) -> Option<u8>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u8
sourceimpl ArithmeticCheckedShl<i16> for u8
impl ArithmeticCheckedShl<i16> for u8
sourcefn arithmetic_checked_shl(self, bits: i16) -> Option<u8>
fn arithmetic_checked_shl(self, bits: i16) -> Option<u8>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u8
sourceimpl ArithmeticCheckedShl<i32> for u8
impl ArithmeticCheckedShl<i32> for u8
sourcefn arithmetic_checked_shl(self, bits: i32) -> Option<u8>
fn arithmetic_checked_shl(self, bits: i32) -> Option<u8>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u8
sourceimpl ArithmeticCheckedShl<i64> for u8
impl ArithmeticCheckedShl<i64> for u8
sourcefn arithmetic_checked_shl(self, bits: i64) -> Option<u8>
fn arithmetic_checked_shl(self, bits: i64) -> Option<u8>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u8
sourceimpl ArithmeticCheckedShl<i128> for u8
impl ArithmeticCheckedShl<i128> for u8
sourcefn arithmetic_checked_shl(self, bits: i128) -> Option<u8>
fn arithmetic_checked_shl(self, bits: i128) -> Option<u8>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u8
sourceimpl ArithmeticCheckedShl<isize> for u8
impl ArithmeticCheckedShl<isize> for u8
sourcefn arithmetic_checked_shl(self, bits: isize) -> Option<u8>
fn arithmetic_checked_shl(self, bits: isize) -> Option<u8>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u8
sourceimpl ArithmeticCheckedShl<i8> for u16
impl ArithmeticCheckedShl<i8> for u16
sourcefn arithmetic_checked_shl(self, bits: i8) -> Option<u16>
fn arithmetic_checked_shl(self, bits: i8) -> Option<u16>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u16
sourceimpl ArithmeticCheckedShl<i16> for u16
impl ArithmeticCheckedShl<i16> for u16
sourcefn arithmetic_checked_shl(self, bits: i16) -> Option<u16>
fn arithmetic_checked_shl(self, bits: i16) -> Option<u16>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u16
sourceimpl ArithmeticCheckedShl<i32> for u16
impl ArithmeticCheckedShl<i32> for u16
sourcefn arithmetic_checked_shl(self, bits: i32) -> Option<u16>
fn arithmetic_checked_shl(self, bits: i32) -> Option<u16>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u16
sourceimpl ArithmeticCheckedShl<i64> for u16
impl ArithmeticCheckedShl<i64> for u16
sourcefn arithmetic_checked_shl(self, bits: i64) -> Option<u16>
fn arithmetic_checked_shl(self, bits: i64) -> Option<u16>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u16
sourceimpl ArithmeticCheckedShl<i128> for u16
impl ArithmeticCheckedShl<i128> for u16
sourcefn arithmetic_checked_shl(self, bits: i128) -> Option<u16>
fn arithmetic_checked_shl(self, bits: i128) -> Option<u16>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u16
sourceimpl ArithmeticCheckedShl<isize> for u16
impl ArithmeticCheckedShl<isize> for u16
sourcefn arithmetic_checked_shl(self, bits: isize) -> Option<u16>
fn arithmetic_checked_shl(self, bits: isize) -> Option<u16>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u16
sourceimpl ArithmeticCheckedShl<i8> for u32
impl ArithmeticCheckedShl<i8> for u32
sourcefn arithmetic_checked_shl(self, bits: i8) -> Option<u32>
fn arithmetic_checked_shl(self, bits: i8) -> Option<u32>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u32
sourceimpl ArithmeticCheckedShl<i16> for u32
impl ArithmeticCheckedShl<i16> for u32
sourcefn arithmetic_checked_shl(self, bits: i16) -> Option<u32>
fn arithmetic_checked_shl(self, bits: i16) -> Option<u32>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u32
sourceimpl ArithmeticCheckedShl<i32> for u32
impl ArithmeticCheckedShl<i32> for u32
sourcefn arithmetic_checked_shl(self, bits: i32) -> Option<u32>
fn arithmetic_checked_shl(self, bits: i32) -> Option<u32>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u32
sourceimpl ArithmeticCheckedShl<i64> for u32
impl ArithmeticCheckedShl<i64> for u32
sourcefn arithmetic_checked_shl(self, bits: i64) -> Option<u32>
fn arithmetic_checked_shl(self, bits: i64) -> Option<u32>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u32
sourceimpl ArithmeticCheckedShl<i128> for u32
impl ArithmeticCheckedShl<i128> for u32
sourcefn arithmetic_checked_shl(self, bits: i128) -> Option<u32>
fn arithmetic_checked_shl(self, bits: i128) -> Option<u32>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u32
sourceimpl ArithmeticCheckedShl<isize> for u32
impl ArithmeticCheckedShl<isize> for u32
sourcefn arithmetic_checked_shl(self, bits: isize) -> Option<u32>
fn arithmetic_checked_shl(self, bits: isize) -> Option<u32>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u32
sourceimpl ArithmeticCheckedShl<i8> for u64
impl ArithmeticCheckedShl<i8> for u64
sourcefn arithmetic_checked_shl(self, bits: i8) -> Option<u64>
fn arithmetic_checked_shl(self, bits: i8) -> Option<u64>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u64
sourceimpl ArithmeticCheckedShl<i16> for u64
impl ArithmeticCheckedShl<i16> for u64
sourcefn arithmetic_checked_shl(self, bits: i16) -> Option<u64>
fn arithmetic_checked_shl(self, bits: i16) -> Option<u64>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u64
sourceimpl ArithmeticCheckedShl<i32> for u64
impl ArithmeticCheckedShl<i32> for u64
sourcefn arithmetic_checked_shl(self, bits: i32) -> Option<u64>
fn arithmetic_checked_shl(self, bits: i32) -> Option<u64>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u64
sourceimpl ArithmeticCheckedShl<i64> for u64
impl ArithmeticCheckedShl<i64> for u64
sourcefn arithmetic_checked_shl(self, bits: i64) -> Option<u64>
fn arithmetic_checked_shl(self, bits: i64) -> Option<u64>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u64
sourceimpl ArithmeticCheckedShl<i128> for u64
impl ArithmeticCheckedShl<i128> for u64
sourcefn arithmetic_checked_shl(self, bits: i128) -> Option<u64>
fn arithmetic_checked_shl(self, bits: i128) -> Option<u64>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u64
sourceimpl ArithmeticCheckedShl<isize> for u64
impl ArithmeticCheckedShl<isize> for u64
sourcefn arithmetic_checked_shl(self, bits: isize) -> Option<u64>
fn arithmetic_checked_shl(self, bits: isize) -> Option<u64>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u64
sourceimpl ArithmeticCheckedShl<i8> for u128
impl ArithmeticCheckedShl<i8> for u128
sourcefn arithmetic_checked_shl(self, bits: i8) -> Option<u128>
fn arithmetic_checked_shl(self, bits: i8) -> Option<u128>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u128
sourceimpl ArithmeticCheckedShl<i16> for u128
impl ArithmeticCheckedShl<i16> for u128
sourcefn arithmetic_checked_shl(self, bits: i16) -> Option<u128>
fn arithmetic_checked_shl(self, bits: i16) -> Option<u128>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u128
sourceimpl ArithmeticCheckedShl<i32> for u128
impl ArithmeticCheckedShl<i32> for u128
sourcefn arithmetic_checked_shl(self, bits: i32) -> Option<u128>
fn arithmetic_checked_shl(self, bits: i32) -> Option<u128>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u128
sourceimpl ArithmeticCheckedShl<i64> for u128
impl ArithmeticCheckedShl<i64> for u128
sourcefn arithmetic_checked_shl(self, bits: i64) -> Option<u128>
fn arithmetic_checked_shl(self, bits: i64) -> Option<u128>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u128
sourceimpl ArithmeticCheckedShl<i128> for u128
impl ArithmeticCheckedShl<i128> for u128
sourcefn arithmetic_checked_shl(self, bits: i128) -> Option<u128>
fn arithmetic_checked_shl(self, bits: i128) -> Option<u128>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u128
sourceimpl ArithmeticCheckedShl<isize> for u128
impl ArithmeticCheckedShl<isize> for u128
sourcefn arithmetic_checked_shl(self, bits: isize) -> Option<u128>
fn arithmetic_checked_shl(self, bits: isize) -> Option<u128>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = u128
sourceimpl ArithmeticCheckedShl<i8> for usize
impl ArithmeticCheckedShl<i8> for usize
sourcefn arithmetic_checked_shl(self, bits: i8) -> Option<usize>
fn arithmetic_checked_shl(self, bits: i8) -> Option<usize>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = usize
sourceimpl ArithmeticCheckedShl<i16> for usize
impl ArithmeticCheckedShl<i16> for usize
sourcefn arithmetic_checked_shl(self, bits: i16) -> Option<usize>
fn arithmetic_checked_shl(self, bits: i16) -> Option<usize>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = usize
sourceimpl ArithmeticCheckedShl<i32> for usize
impl ArithmeticCheckedShl<i32> for usize
sourcefn arithmetic_checked_shl(self, bits: i32) -> Option<usize>
fn arithmetic_checked_shl(self, bits: i32) -> Option<usize>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = usize
sourceimpl ArithmeticCheckedShl<i64> for usize
impl ArithmeticCheckedShl<i64> for usize
sourcefn arithmetic_checked_shl(self, bits: i64) -> Option<usize>
fn arithmetic_checked_shl(self, bits: i64) -> Option<usize>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = usize
sourceimpl ArithmeticCheckedShl<i128> for usize
impl ArithmeticCheckedShl<i128> for usize
sourcefn arithmetic_checked_shl(self, bits: i128) -> Option<usize>
fn arithmetic_checked_shl(self, bits: i128) -> Option<usize>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = usize
sourceimpl ArithmeticCheckedShl<isize> for usize
impl ArithmeticCheckedShl<isize> for usize
sourcefn arithmetic_checked_shl(self, bits: isize) -> Option<usize>
fn arithmetic_checked_shl(self, bits: isize) -> Option<usize>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}\ 2^b x < 2^W, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and} \ 2^b x \geq 2^W, \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) &
\text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = usize
sourceimpl ArithmeticCheckedShl<u8> for i8
impl ArithmeticCheckedShl<u8> for i8
sourcefn arithmetic_checked_shl(self, bits: u8) -> Option<i8>
fn arithmetic_checked_shl(self, bits: u8) -> Option<i8>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u16> for i8
impl ArithmeticCheckedShl<u16> for i8
sourcefn arithmetic_checked_shl(self, bits: u16) -> Option<i8>
fn arithmetic_checked_shl(self, bits: u16) -> Option<i8>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u32> for i8
impl ArithmeticCheckedShl<u32> for i8
sourcefn arithmetic_checked_shl(self, bits: u32) -> Option<i8>
fn arithmetic_checked_shl(self, bits: u32) -> Option<i8>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u64> for i8
impl ArithmeticCheckedShl<u64> for i8
sourcefn arithmetic_checked_shl(self, bits: u64) -> Option<i8>
fn arithmetic_checked_shl(self, bits: u64) -> Option<i8>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u128> for i8
impl ArithmeticCheckedShl<u128> for i8
sourcefn arithmetic_checked_shl(self, bits: u128) -> Option<i8>
fn arithmetic_checked_shl(self, bits: u128) -> Option<i8>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<usize> for i8
impl ArithmeticCheckedShl<usize> for i8
sourcefn arithmetic_checked_shl(self, bits: usize) -> Option<i8>
fn arithmetic_checked_shl(self, bits: usize) -> Option<i8>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u8> for i16
impl ArithmeticCheckedShl<u8> for i16
sourcefn arithmetic_checked_shl(self, bits: u8) -> Option<i16>
fn arithmetic_checked_shl(self, bits: u8) -> Option<i16>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u16> for i16
impl ArithmeticCheckedShl<u16> for i16
sourcefn arithmetic_checked_shl(self, bits: u16) -> Option<i16>
fn arithmetic_checked_shl(self, bits: u16) -> Option<i16>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u32> for i16
impl ArithmeticCheckedShl<u32> for i16
sourcefn arithmetic_checked_shl(self, bits: u32) -> Option<i16>
fn arithmetic_checked_shl(self, bits: u32) -> Option<i16>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u64> for i16
impl ArithmeticCheckedShl<u64> for i16
sourcefn arithmetic_checked_shl(self, bits: u64) -> Option<i16>
fn arithmetic_checked_shl(self, bits: u64) -> Option<i16>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u128> for i16
impl ArithmeticCheckedShl<u128> for i16
sourcefn arithmetic_checked_shl(self, bits: u128) -> Option<i16>
fn arithmetic_checked_shl(self, bits: u128) -> Option<i16>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<usize> for i16
impl ArithmeticCheckedShl<usize> for i16
sourcefn arithmetic_checked_shl(self, bits: usize) -> Option<i16>
fn arithmetic_checked_shl(self, bits: usize) -> Option<i16>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u8> for i32
impl ArithmeticCheckedShl<u8> for i32
sourcefn arithmetic_checked_shl(self, bits: u8) -> Option<i32>
fn arithmetic_checked_shl(self, bits: u8) -> Option<i32>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u16> for i32
impl ArithmeticCheckedShl<u16> for i32
sourcefn arithmetic_checked_shl(self, bits: u16) -> Option<i32>
fn arithmetic_checked_shl(self, bits: u16) -> Option<i32>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u32> for i32
impl ArithmeticCheckedShl<u32> for i32
sourcefn arithmetic_checked_shl(self, bits: u32) -> Option<i32>
fn arithmetic_checked_shl(self, bits: u32) -> Option<i32>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u64> for i32
impl ArithmeticCheckedShl<u64> for i32
sourcefn arithmetic_checked_shl(self, bits: u64) -> Option<i32>
fn arithmetic_checked_shl(self, bits: u64) -> Option<i32>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u128> for i32
impl ArithmeticCheckedShl<u128> for i32
sourcefn arithmetic_checked_shl(self, bits: u128) -> Option<i32>
fn arithmetic_checked_shl(self, bits: u128) -> Option<i32>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<usize> for i32
impl ArithmeticCheckedShl<usize> for i32
sourcefn arithmetic_checked_shl(self, bits: usize) -> Option<i32>
fn arithmetic_checked_shl(self, bits: usize) -> Option<i32>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u8> for i64
impl ArithmeticCheckedShl<u8> for i64
sourcefn arithmetic_checked_shl(self, bits: u8) -> Option<i64>
fn arithmetic_checked_shl(self, bits: u8) -> Option<i64>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u16> for i64
impl ArithmeticCheckedShl<u16> for i64
sourcefn arithmetic_checked_shl(self, bits: u16) -> Option<i64>
fn arithmetic_checked_shl(self, bits: u16) -> Option<i64>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u32> for i64
impl ArithmeticCheckedShl<u32> for i64
sourcefn arithmetic_checked_shl(self, bits: u32) -> Option<i64>
fn arithmetic_checked_shl(self, bits: u32) -> Option<i64>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u64> for i64
impl ArithmeticCheckedShl<u64> for i64
sourcefn arithmetic_checked_shl(self, bits: u64) -> Option<i64>
fn arithmetic_checked_shl(self, bits: u64) -> Option<i64>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u128> for i64
impl ArithmeticCheckedShl<u128> for i64
sourcefn arithmetic_checked_shl(self, bits: u128) -> Option<i64>
fn arithmetic_checked_shl(self, bits: u128) -> Option<i64>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<usize> for i64
impl ArithmeticCheckedShl<usize> for i64
sourcefn arithmetic_checked_shl(self, bits: usize) -> Option<i64>
fn arithmetic_checked_shl(self, bits: usize) -> Option<i64>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u8> for i128
impl ArithmeticCheckedShl<u8> for i128
sourcefn arithmetic_checked_shl(self, bits: u8) -> Option<i128>
fn arithmetic_checked_shl(self, bits: u8) -> Option<i128>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u16> for i128
impl ArithmeticCheckedShl<u16> for i128
sourcefn arithmetic_checked_shl(self, bits: u16) -> Option<i128>
fn arithmetic_checked_shl(self, bits: u16) -> Option<i128>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u32> for i128
impl ArithmeticCheckedShl<u32> for i128
sourcefn arithmetic_checked_shl(self, bits: u32) -> Option<i128>
fn arithmetic_checked_shl(self, bits: u32) -> Option<i128>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u64> for i128
impl ArithmeticCheckedShl<u64> for i128
sourcefn arithmetic_checked_shl(self, bits: u64) -> Option<i128>
fn arithmetic_checked_shl(self, bits: u64) -> Option<i128>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u128> for i128
impl ArithmeticCheckedShl<u128> for i128
sourcefn arithmetic_checked_shl(self, bits: u128) -> Option<i128>
fn arithmetic_checked_shl(self, bits: u128) -> Option<i128>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<usize> for i128
impl ArithmeticCheckedShl<usize> for i128
sourcefn arithmetic_checked_shl(self, bits: usize) -> Option<i128>
fn arithmetic_checked_shl(self, bits: usize) -> Option<i128>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u8> for isize
impl ArithmeticCheckedShl<u8> for isize
sourcefn arithmetic_checked_shl(self, bits: u8) -> Option<isize>
fn arithmetic_checked_shl(self, bits: u8) -> Option<isize>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u16> for isize
impl ArithmeticCheckedShl<u16> for isize
sourcefn arithmetic_checked_shl(self, bits: u16) -> Option<isize>
fn arithmetic_checked_shl(self, bits: u16) -> Option<isize>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u32> for isize
impl ArithmeticCheckedShl<u32> for isize
sourcefn arithmetic_checked_shl(self, bits: u32) -> Option<isize>
fn arithmetic_checked_shl(self, bits: u32) -> Option<isize>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u64> for isize
impl ArithmeticCheckedShl<u64> for isize
sourcefn arithmetic_checked_shl(self, bits: u64) -> Option<isize>
fn arithmetic_checked_shl(self, bits: u64) -> Option<isize>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<u128> for isize
impl ArithmeticCheckedShl<u128> for isize
sourcefn arithmetic_checked_shl(self, bits: u128) -> Option<isize>
fn arithmetic_checked_shl(self, bits: u128) -> Option<isize>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<usize> for isize
impl ArithmeticCheckedShl<usize> for isize
sourcefn arithmetic_checked_shl(self, bits: usize) -> Option<isize>
fn arithmetic_checked_shl(self, bits: usize) -> Option<isize>
Left-shifts a number (multiplies 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.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad 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 ArithmeticCheckedShl<i8> for i8
impl ArithmeticCheckedShl<i8> for i8
sourcefn arithmetic_checked_shl(self, bits: i8) -> Option<i8>
fn arithmetic_checked_shl(self, bits: i8) -> Option<i8>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i8
sourceimpl ArithmeticCheckedShl<i16> for i8
impl ArithmeticCheckedShl<i16> for i8
sourcefn arithmetic_checked_shl(self, bits: i16) -> Option<i8>
fn arithmetic_checked_shl(self, bits: i16) -> Option<i8>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i8
sourceimpl ArithmeticCheckedShl<i32> for i8
impl ArithmeticCheckedShl<i32> for i8
sourcefn arithmetic_checked_shl(self, bits: i32) -> Option<i8>
fn arithmetic_checked_shl(self, bits: i32) -> Option<i8>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i8
sourceimpl ArithmeticCheckedShl<i64> for i8
impl ArithmeticCheckedShl<i64> for i8
sourcefn arithmetic_checked_shl(self, bits: i64) -> Option<i8>
fn arithmetic_checked_shl(self, bits: i64) -> Option<i8>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i8
sourceimpl ArithmeticCheckedShl<i128> for i8
impl ArithmeticCheckedShl<i128> for i8
sourcefn arithmetic_checked_shl(self, bits: i128) -> Option<i8>
fn arithmetic_checked_shl(self, bits: i128) -> Option<i8>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i8
sourceimpl ArithmeticCheckedShl<isize> for i8
impl ArithmeticCheckedShl<isize> for i8
sourcefn arithmetic_checked_shl(self, bits: isize) -> Option<i8>
fn arithmetic_checked_shl(self, bits: isize) -> Option<i8>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i8
sourceimpl ArithmeticCheckedShl<i8> for i16
impl ArithmeticCheckedShl<i8> for i16
sourcefn arithmetic_checked_shl(self, bits: i8) -> Option<i16>
fn arithmetic_checked_shl(self, bits: i8) -> Option<i16>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i16
sourceimpl ArithmeticCheckedShl<i16> for i16
impl ArithmeticCheckedShl<i16> for i16
sourcefn arithmetic_checked_shl(self, bits: i16) -> Option<i16>
fn arithmetic_checked_shl(self, bits: i16) -> Option<i16>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i16
sourceimpl ArithmeticCheckedShl<i32> for i16
impl ArithmeticCheckedShl<i32> for i16
sourcefn arithmetic_checked_shl(self, bits: i32) -> Option<i16>
fn arithmetic_checked_shl(self, bits: i32) -> Option<i16>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i16
sourceimpl ArithmeticCheckedShl<i64> for i16
impl ArithmeticCheckedShl<i64> for i16
sourcefn arithmetic_checked_shl(self, bits: i64) -> Option<i16>
fn arithmetic_checked_shl(self, bits: i64) -> Option<i16>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i16
sourceimpl ArithmeticCheckedShl<i128> for i16
impl ArithmeticCheckedShl<i128> for i16
sourcefn arithmetic_checked_shl(self, bits: i128) -> Option<i16>
fn arithmetic_checked_shl(self, bits: i128) -> Option<i16>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i16
sourceimpl ArithmeticCheckedShl<isize> for i16
impl ArithmeticCheckedShl<isize> for i16
sourcefn arithmetic_checked_shl(self, bits: isize) -> Option<i16>
fn arithmetic_checked_shl(self, bits: isize) -> Option<i16>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i16
sourceimpl ArithmeticCheckedShl<i8> for i32
impl ArithmeticCheckedShl<i8> for i32
sourcefn arithmetic_checked_shl(self, bits: i8) -> Option<i32>
fn arithmetic_checked_shl(self, bits: i8) -> Option<i32>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i32
sourceimpl ArithmeticCheckedShl<i16> for i32
impl ArithmeticCheckedShl<i16> for i32
sourcefn arithmetic_checked_shl(self, bits: i16) -> Option<i32>
fn arithmetic_checked_shl(self, bits: i16) -> Option<i32>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i32
sourceimpl ArithmeticCheckedShl<i32> for i32
impl ArithmeticCheckedShl<i32> for i32
sourcefn arithmetic_checked_shl(self, bits: i32) -> Option<i32>
fn arithmetic_checked_shl(self, bits: i32) -> Option<i32>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i32
sourceimpl ArithmeticCheckedShl<i64> for i32
impl ArithmeticCheckedShl<i64> for i32
sourcefn arithmetic_checked_shl(self, bits: i64) -> Option<i32>
fn arithmetic_checked_shl(self, bits: i64) -> Option<i32>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i32
sourceimpl ArithmeticCheckedShl<i128> for i32
impl ArithmeticCheckedShl<i128> for i32
sourcefn arithmetic_checked_shl(self, bits: i128) -> Option<i32>
fn arithmetic_checked_shl(self, bits: i128) -> Option<i32>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i32
sourceimpl ArithmeticCheckedShl<isize> for i32
impl ArithmeticCheckedShl<isize> for i32
sourcefn arithmetic_checked_shl(self, bits: isize) -> Option<i32>
fn arithmetic_checked_shl(self, bits: isize) -> Option<i32>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i32
sourceimpl ArithmeticCheckedShl<i8> for i64
impl ArithmeticCheckedShl<i8> for i64
sourcefn arithmetic_checked_shl(self, bits: i8) -> Option<i64>
fn arithmetic_checked_shl(self, bits: i8) -> Option<i64>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i64
sourceimpl ArithmeticCheckedShl<i16> for i64
impl ArithmeticCheckedShl<i16> for i64
sourcefn arithmetic_checked_shl(self, bits: i16) -> Option<i64>
fn arithmetic_checked_shl(self, bits: i16) -> Option<i64>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i64
sourceimpl ArithmeticCheckedShl<i32> for i64
impl ArithmeticCheckedShl<i32> for i64
sourcefn arithmetic_checked_shl(self, bits: i32) -> Option<i64>
fn arithmetic_checked_shl(self, bits: i32) -> Option<i64>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i64
sourceimpl ArithmeticCheckedShl<i64> for i64
impl ArithmeticCheckedShl<i64> for i64
sourcefn arithmetic_checked_shl(self, bits: i64) -> Option<i64>
fn arithmetic_checked_shl(self, bits: i64) -> Option<i64>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i64
sourceimpl ArithmeticCheckedShl<i128> for i64
impl ArithmeticCheckedShl<i128> for i64
sourcefn arithmetic_checked_shl(self, bits: i128) -> Option<i64>
fn arithmetic_checked_shl(self, bits: i128) -> Option<i64>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i64
sourceimpl ArithmeticCheckedShl<isize> for i64
impl ArithmeticCheckedShl<isize> for i64
sourcefn arithmetic_checked_shl(self, bits: isize) -> Option<i64>
fn arithmetic_checked_shl(self, bits: isize) -> Option<i64>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i64
sourceimpl ArithmeticCheckedShl<i8> for i128
impl ArithmeticCheckedShl<i8> for i128
sourcefn arithmetic_checked_shl(self, bits: i8) -> Option<i128>
fn arithmetic_checked_shl(self, bits: i8) -> Option<i128>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i128
sourceimpl ArithmeticCheckedShl<i16> for i128
impl ArithmeticCheckedShl<i16> for i128
sourcefn arithmetic_checked_shl(self, bits: i16) -> Option<i128>
fn arithmetic_checked_shl(self, bits: i16) -> Option<i128>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i128
sourceimpl ArithmeticCheckedShl<i32> for i128
impl ArithmeticCheckedShl<i32> for i128
sourcefn arithmetic_checked_shl(self, bits: i32) -> Option<i128>
fn arithmetic_checked_shl(self, bits: i32) -> Option<i128>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i128
sourceimpl ArithmeticCheckedShl<i64> for i128
impl ArithmeticCheckedShl<i64> for i128
sourcefn arithmetic_checked_shl(self, bits: i64) -> Option<i128>
fn arithmetic_checked_shl(self, bits: i64) -> Option<i128>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i128
sourceimpl ArithmeticCheckedShl<i128> for i128
impl ArithmeticCheckedShl<i128> for i128
sourcefn arithmetic_checked_shl(self, bits: i128) -> Option<i128>
fn arithmetic_checked_shl(self, bits: i128) -> Option<i128>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i128
sourceimpl ArithmeticCheckedShl<isize> for i128
impl ArithmeticCheckedShl<isize> for i128
sourcefn arithmetic_checked_shl(self, bits: isize) -> Option<i128>
fn arithmetic_checked_shl(self, bits: isize) -> Option<i128>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = i128
sourceimpl ArithmeticCheckedShl<i8> for isize
impl ArithmeticCheckedShl<i8> for isize
sourcefn arithmetic_checked_shl(self, bits: i8) -> Option<isize>
fn arithmetic_checked_shl(self, bits: i8) -> Option<isize>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = isize
sourceimpl ArithmeticCheckedShl<i16> for isize
impl ArithmeticCheckedShl<i16> for isize
sourcefn arithmetic_checked_shl(self, bits: i16) -> Option<isize>
fn arithmetic_checked_shl(self, bits: i16) -> Option<isize>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = isize
sourceimpl ArithmeticCheckedShl<i32> for isize
impl ArithmeticCheckedShl<i32> for isize
sourcefn arithmetic_checked_shl(self, bits: i32) -> Option<isize>
fn arithmetic_checked_shl(self, bits: i32) -> Option<isize>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = isize
sourceimpl ArithmeticCheckedShl<i64> for isize
impl ArithmeticCheckedShl<i64> for isize
sourcefn arithmetic_checked_shl(self, bits: i64) -> Option<isize>
fn arithmetic_checked_shl(self, bits: i64) -> Option<isize>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = isize
sourceimpl ArithmeticCheckedShl<i128> for isize
impl ArithmeticCheckedShl<i128> for isize
sourcefn arithmetic_checked_shl(self, bits: i128) -> Option<isize>
fn arithmetic_checked_shl(self, bits: i128) -> Option<isize>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
type Output = isize
sourceimpl ArithmeticCheckedShl<isize> for isize
impl ArithmeticCheckedShl<isize> for isize
sourcefn arithmetic_checked_shl(self, bits: isize) -> Option<isize>
fn arithmetic_checked_shl(self, bits: isize) -> Option<isize>
Left-shifts a number (multiplies 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
negative amount; shifting by a negative amount with a high absolute value
returns Some(0)
if self
is positive, and Some(-1)
if self
is
negative.
$$
f(x, b) = \begin{cases}
\operatorname{Some}(2^b x) &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ -2^{W-1} \leq 2^b x < 2^{W-1}, \\
\operatorname{None} &
\text{if} \quad b \geq 0 \ \mathrm{and}
\ (2^b x < -2^{W-1} \ \mathrm{or} \ 2^b x \geq 2^{W-1}), \\
\operatorname{Some}(\lfloor x/2^{-b} \rfloor) & \text{if} \quad b < 0,
\end{cases}
$$
where $W$ is Self::WIDTH
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.