Struct bounded_integer::BoundedIsize

#[repr(transparent)]
pub struct BoundedIsize<const MIN: isize, const MAX: isize>(_);

Available on crate feature types only.

An isize constrained to be in the range MIN..=MAX.

Implementations

impl<const MIN: isize, const MAX: isize> Bounded<MIN, MAX>

pub const MIN_VALUE: isize = MIN

The smallest value this bounded integer can contain.

pub const MAX_VALUE: isize = MAX

The largest value that this bounded integer can contain.

pub const MIN: Self = _

The smallest value of the bounded integer.

pub const MAX: Self = _

The largest value of the bounded integer.

pub const unsafe fn new_unchecked(n: isize) -> Self

Creates a bounded integer without checking the value.

Safety

The value must not be outside the valid range of values; it must not be less than MIN_VALUE or greater than MAX_VALUE.

pub unsafe fn new_ref_unchecked(n: &isize) -> &Self

Creates a shared reference to a bounded integer from a shared reference to a primitive.

Safety

The value must not be outside the valid range of values; it must not be less than MIN_VALUE or greater than MAX_VALUE.

pub unsafe fn new_mut_unchecked(n: &mut isize) -> &mut Self

Creates a mutable reference to a bounded integer from a mutable reference to a primitive.

Safety

The value must not be outside the valid range of values; it must not be less than MIN_VALUE or greater than MAX_VALUE.

pub const fn in_range(n: isize) -> bool

Checks whether the given value is in the range of the bounded integer.

pub const fn new(n: isize) -> Option<Self>

Creates a bounded integer if the given value is within the range [MIN, MAX].

pub fn new_ref(n: &isize) -> Option<&Self>

Creates a reference to a bounded integer from a reference to a primitive if the given value is within the range [MIN, MAX].

pub fn new_mut(n: &mut isize) -> Option<&mut Self>

Creates a mutable reference to a bounded integer from a mutable reference to a primitive if the given value is within the range [MIN, MAX].

pub const fn new_saturating(n: isize) -> Self

Creates a bounded integer by setting the value to MIN or MAX if it is too low or too high respectively.

pub fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseError>

Converts a string slice in a given base to the bounded integer.

Panics

Panics if radix is below 2 or above 36.

pub const fn get(self) -> isize

Returns the value of the bounded integer as a primitive type.

pub const fn get_ref(&self) -> &isize

Returns a shared reference to the value of the bounded integer.

pub unsafe fn get_mut(&mut self) -> &mut isize

Returns a mutable reference to the value of the bounded integer.

Safety

This value must never be set to a value beyond the range of the bounded integer.

pub fn abs(self) -> Self

Computes the absolute value of self, panicking if it is out of range.

pub fn pow(self, exp: u32) -> Self

Raises self to the power of exp, using exponentiation by squaring. Panics if it is out of range.

pub fn div_euclid(self, rhs: isize) -> Self

Calculates the quotient of Euclidean division of self by rhs. Panics if rhs is 0 or the result is out of range.

pub fn rem_euclid(self, rhs: isize) -> Self

Calculates the least nonnegative remainder of self (mod rhs). Panics if rhs is 0 or the result is out of range.

pub const fn checked_add(self, rhs: isize) -> Option<Self>

Checked integer addition.

pub const fn saturating_add(self, rhs: isize) -> Self

Saturating integer addition.

pub const fn checked_sub(self, rhs: isize) -> Option<Self>

Checked integer subtraction.

pub const fn saturating_sub(self, rhs: isize) -> Self

Saturating integer subtraction.

pub const fn checked_mul(self, rhs: isize) -> Option<Self>

Checked integer multiplication.

pub const fn saturating_mul(self, rhs: isize) -> Self

Saturating integer multiplication.

pub const fn checked_div(self, rhs: isize) -> Option<Self>

Checked integer division.

pub const fn checked_div_euclid(self, rhs: isize) -> Option<Self>

Checked Euclidean division.

pub const fn checked_rem(self, rhs: isize) -> Option<Self>

Checked integer remainder.

pub const fn checked_rem_euclid(self, rhs: isize) -> Option<Self>

Checked Euclidean remainder.

pub const fn checked_neg(self) -> Option<Self>

Checked negation.

pub const fn saturating_neg(self) -> Self

Saturating negation.

pub const fn checked_abs(self) -> Option<Self>

Checked absolute value.

pub const fn saturating_abs(self) -> Self

Saturating absolute value.

pub const fn checked_pow(self, rhs: u32) -> Option<Self>

Checked exponentiation.

pub const fn saturating_pow(self, rhs: u32) -> Self

Saturating exponentiation.

pub const fn checked_shl(self, rhs: u32) -> Option<Self>

Checked shift left.

pub const fn checked_shr(self, rhs: u32) -> Option<Self>

Checked shift right.

Trait Implementations

impl<const MIN: isize, const MAX: isize> Add<&Bounded<MIN, MAX>> for &isize

type Output = isize

The resulting type after applying the + operator.

fn add(self, rhs: &Bounded<MIN, MAX>) -> Self::Output

Performs the + operation.

impl<const MIN: isize, const MAX: isize> Add<&Bounded<MIN, MAX>> for isize

type Output = isize

The resulting type after applying the + operator.

fn add(self, rhs: &Bounded<MIN, MAX>) -> Self::Output

Performs the + operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Add<&Bounded<R_MIN, R_MAX>> for &Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the + operator.

fn add(self, rhs: &Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the + operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Add<&Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the + operator.

fn add(self, rhs: &Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the + operation.

impl<const MIN: isize, const MAX: isize> Add<&isize> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the + operator.

fn add(self, rhs: &isize) -> Self::Output

Performs the + operation.

impl<const MIN: isize, const MAX: isize> Add<&isize> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the + operator.

fn add(self, rhs: &isize) -> Self::Output

Performs the + operation.

impl<const MIN: isize, const MAX: isize> Add<Bounded<MIN, MAX>> for &isize

type Output = isize

The resulting type after applying the + operator.

fn add(self, rhs: Bounded<MIN, MAX>) -> Self::Output

Performs the + operation.

impl<const MIN: isize, const MAX: isize> Add<Bounded<MIN, MAX>> for isize

type Output = isize

The resulting type after applying the + operator.

fn add(self, rhs: Bounded<MIN, MAX>) -> Self::Output

Performs the + operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Add<Bounded<R_MIN, R_MAX>> for &Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the + operator.

fn add(self, rhs: Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the + operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Add<Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the + operator.

fn add(self, rhs: Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the + operation.

impl<const MIN: isize, const MAX: isize> Add<isize> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the + operator.

fn add(self, rhs: isize) -> Self::Output

Performs the + operation.

impl<const MIN: isize, const MAX: isize> Add<isize> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the + operator.

fn add(self, rhs: isize) -> Self::Output

Performs the + operation.

impl<const MIN: isize, const MAX: isize> AddAssign<&Bounded<MIN, MAX>> for isize

fn add_assign(&mut self, rhs: &Bounded<MIN, MAX>)

Performs the += operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> AddAssign<&Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

fn add_assign(&mut self, rhs: &Bounded<R_MIN, R_MAX>)

Performs the += operation.

impl<const MIN: isize, const MAX: isize> AddAssign<&isize> for Bounded<MIN, MAX>

fn add_assign(&mut self, rhs: &isize)

Performs the += operation.

impl<const MIN: isize, const MAX: isize> AddAssign<Bounded<MIN, MAX>> for isize

fn add_assign(&mut self, rhs: Bounded<MIN, MAX>)

Performs the += operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> AddAssign<Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

fn add_assign(&mut self, rhs: Bounded<R_MIN, R_MAX>)

Performs the += operation.

impl<const MIN: isize, const MAX: isize> AddAssign<isize> for Bounded<MIN, MAX>

fn add_assign(&mut self, rhs: isize)

Performs the += operation.

impl<'a, const MIN: isize, const MAX: isize> Arbitrary<'a> for Bounded<MIN, MAX>

Available on crate feature arbitrary1 only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

impl<T, const MIN: isize, const MAX: isize> AsPrimitive<T> for Bounded<MIN, MAX>where isize: AsPrimitive<T>, T: 'static + Copy,

Available on crate feature num-traits02 only.

fn as_(self) -> T

Convert a value to another, using the as operator.

impl<const MIN: isize, const MAX: isize> AsRef<isize> for Bounded<MIN, MAX>

fn as_ref(&self) -> &isize

Converts this type into a shared reference of the (usually inferred) input type.

impl<const MIN: isize, const MAX: isize> Binary for Bounded<MIN, MAX>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const MIN: isize, const MAX: isize> BitAnd<&Bounded<MIN, MAX>> for &isize

type Output = isize

The resulting type after applying the & operator.

fn bitand(self, rhs: &Bounded<MIN, MAX>) -> Self::Output

Performs the & operation.

impl<const MIN: isize, const MAX: isize> BitAnd<&Bounded<MIN, MAX>> for isize

type Output = isize

The resulting type after applying the & operator.

fn bitand(self, rhs: &Bounded<MIN, MAX>) -> Self::Output

Performs the & operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> BitAnd<&Bounded<R_MIN, R_MAX>> for &Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the & operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> BitAnd<&Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the & operation.

impl<const MIN: isize, const MAX: isize> BitAnd<&isize> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the & operator.

fn bitand(self, rhs: &isize) -> Self::Output

Performs the & operation.

impl<const MIN: isize, const MAX: isize> BitAnd<&isize> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the & operator.

fn bitand(self, rhs: &isize) -> Self::Output

Performs the & operation.

impl<const MIN: isize, const MAX: isize> BitAnd<Bounded<MIN, MAX>> for &isize

type Output = isize

The resulting type after applying the & operator.

fn bitand(self, rhs: Bounded<MIN, MAX>) -> Self::Output

Performs the & operation.

impl<const MIN: isize, const MAX: isize> BitAnd<Bounded<MIN, MAX>> for isize

type Output = isize

The resulting type after applying the & operator.

fn bitand(self, rhs: Bounded<MIN, MAX>) -> Self::Output

Performs the & operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> BitAnd<Bounded<R_MIN, R_MAX>> for &Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the & operator.

fn bitand(self, rhs: Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the & operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> BitAnd<Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the & operator.

fn bitand(self, rhs: Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the & operation.

impl<const MIN: isize, const MAX: isize> BitAnd<isize> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the & operator.

fn bitand(self, rhs: isize) -> Self::Output

Performs the & operation.

impl<const MIN: isize, const MAX: isize> BitAnd<isize> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the & operator.

fn bitand(self, rhs: isize) -> Self::Output

Performs the & operation.

impl<const MIN: isize, const MAX: isize> BitAndAssign<&Bounded<MIN, MAX>> for isize

fn bitand_assign(&mut self, rhs: &Bounded<MIN, MAX>)

Performs the &= operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> BitAndAssign<&Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

fn bitand_assign(&mut self, rhs: &Bounded<R_MIN, R_MAX>)

Performs the &= operation.

impl<const MIN: isize, const MAX: isize> BitAndAssign<&isize> for Bounded<MIN, MAX>

fn bitand_assign(&mut self, rhs: &isize)

Performs the &= operation.

impl<const MIN: isize, const MAX: isize> BitAndAssign<Bounded<MIN, MAX>> for isize

fn bitand_assign(&mut self, rhs: Bounded<MIN, MAX>)

Performs the &= operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> BitAndAssign<Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

fn bitand_assign(&mut self, rhs: Bounded<R_MIN, R_MAX>)

Performs the &= operation.

impl<const MIN: isize, const MAX: isize> BitAndAssign<isize> for Bounded<MIN, MAX>

fn bitand_assign(&mut self, rhs: isize)

Performs the &= operation.

impl<const MIN: isize, const MAX: isize> BitOr<&Bounded<MIN, MAX>> for &isize

type Output = isize

The resulting type after applying the | operator.

fn bitor(self, rhs: &Bounded<MIN, MAX>) -> Self::Output

Performs the | operation.

impl<const MIN: isize, const MAX: isize> BitOr<&Bounded<MIN, MAX>> for isize

type Output = isize

The resulting type after applying the | operator.

fn bitor(self, rhs: &Bounded<MIN, MAX>) -> Self::Output

Performs the | operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> BitOr<&Bounded<R_MIN, R_MAX>> for &Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the | operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> BitOr<&Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the | operation.

impl<const MIN: isize, const MAX: isize> BitOr<&isize> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the | operator.

fn bitor(self, rhs: &isize) -> Self::Output

Performs the | operation.

impl<const MIN: isize, const MAX: isize> BitOr<&isize> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the | operator.

fn bitor(self, rhs: &isize) -> Self::Output

Performs the | operation.

impl<const MIN: isize, const MAX: isize> BitOr<Bounded<MIN, MAX>> for &isize

type Output = isize

The resulting type after applying the | operator.

fn bitor(self, rhs: Bounded<MIN, MAX>) -> Self::Output

Performs the | operation.

impl<const MIN: isize, const MAX: isize> BitOr<Bounded<MIN, MAX>> for isize

type Output = isize

The resulting type after applying the | operator.

fn bitor(self, rhs: Bounded<MIN, MAX>) -> Self::Output

Performs the | operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> BitOr<Bounded<R_MIN, R_MAX>> for &Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the | operator.

fn bitor(self, rhs: Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the | operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> BitOr<Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the | operator.

fn bitor(self, rhs: Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the | operation.

impl<const MIN: isize, const MAX: isize> BitOr<isize> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the | operator.

fn bitor(self, rhs: isize) -> Self::Output

Performs the | operation.

impl<const MIN: isize, const MAX: isize> BitOr<isize> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the | operator.

fn bitor(self, rhs: isize) -> Self::Output

Performs the | operation.

impl<const MIN: isize, const MAX: isize> BitOrAssign<&Bounded<MIN, MAX>> for isize

fn bitor_assign(&mut self, rhs: &Bounded<MIN, MAX>)

Performs the |= operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> BitOrAssign<&Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

fn bitor_assign(&mut self, rhs: &Bounded<R_MIN, R_MAX>)

Performs the |= operation.

impl<const MIN: isize, const MAX: isize> BitOrAssign<&isize> for Bounded<MIN, MAX>

fn bitor_assign(&mut self, rhs: &isize)

Performs the |= operation.

impl<const MIN: isize, const MAX: isize> BitOrAssign<Bounded<MIN, MAX>> for isize

fn bitor_assign(&mut self, rhs: Bounded<MIN, MAX>)

Performs the |= operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> BitOrAssign<Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

fn bitor_assign(&mut self, rhs: Bounded<R_MIN, R_MAX>)

Performs the |= operation.

impl<const MIN: isize, const MAX: isize> BitOrAssign<isize> for Bounded<MIN, MAX>

fn bitor_assign(&mut self, rhs: isize)

Performs the |= operation.

impl<const MIN: isize, const MAX: isize> BitXor<&Bounded<MIN, MAX>> for &isize

type Output = isize

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Bounded<MIN, MAX>) -> Self::Output

Performs the ^ operation.

impl<const MIN: isize, const MAX: isize> BitXor<&Bounded<MIN, MAX>> for isize

type Output = isize

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Bounded<MIN, MAX>) -> Self::Output

Performs the ^ operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> BitXor<&Bounded<R_MIN, R_MAX>> for &Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the ^ operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> BitXor<&Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the ^ operation.

impl<const MIN: isize, const MAX: isize> BitXor<&isize> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &isize) -> Self::Output

Performs the ^ operation.

impl<const MIN: isize, const MAX: isize> BitXor<&isize> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &isize) -> Self::Output

Performs the ^ operation.

impl<const MIN: isize, const MAX: isize> BitXor<Bounded<MIN, MAX>> for &isize

type Output = isize

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Bounded<MIN, MAX>) -> Self::Output

Performs the ^ operation.

impl<const MIN: isize, const MAX: isize> BitXor<Bounded<MIN, MAX>> for isize

type Output = isize

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Bounded<MIN, MAX>) -> Self::Output

Performs the ^ operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> BitXor<Bounded<R_MIN, R_MAX>> for &Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the ^ operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> BitXor<Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the ^ operation.

impl<const MIN: isize, const MAX: isize> BitXor<isize> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: isize) -> Self::Output

Performs the ^ operation.

impl<const MIN: isize, const MAX: isize> BitXor<isize> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: isize) -> Self::Output

Performs the ^ operation.

impl<const MIN: isize, const MAX: isize> BitXorAssign<&Bounded<MIN, MAX>> for isize

fn bitxor_assign(&mut self, rhs: &Bounded<MIN, MAX>)

Performs the ^= operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> BitXorAssign<&Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

fn bitxor_assign(&mut self, rhs: &Bounded<R_MIN, R_MAX>)

Performs the ^= operation.

impl<const MIN: isize, const MAX: isize> BitXorAssign<&isize> for Bounded<MIN, MAX>

fn bitxor_assign(&mut self, rhs: &isize)

Performs the ^= operation.

impl<const MIN: isize, const MAX: isize> BitXorAssign<Bounded<MIN, MAX>> for isize

fn bitxor_assign(&mut self, rhs: Bounded<MIN, MAX>)

Performs the ^= operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> BitXorAssign<Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

fn bitxor_assign(&mut self, rhs: Bounded<R_MIN, R_MAX>)

Performs the ^= operation.

impl<const MIN: isize, const MAX: isize> BitXorAssign<isize> for Bounded<MIN, MAX>

fn bitxor_assign(&mut self, rhs: isize)

Performs the ^= operation.

impl<const MIN: isize, const MAX: isize> Borrow<isize> for Bounded<MIN, MAX>

fn borrow(&self) -> &isize

Immutably borrows from an owned value.

impl<const MIN: isize, const MAX: isize> Bounded for Bounded<MIN, MAX>

Available on crate feature num-traits02 only.

fn min_value() -> Self

Returns the smallest finite number this type can represent

fn max_value() -> Self

Returns the largest finite number this type can represent

impl<const MIN: isize, const MAX: isize> CheckedAdd for Bounded<MIN, MAX>

Available on crate feature num-traits02 only.

fn checked_add(&self, v: &Self) -> Option<Self>

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl<const MIN: isize, const MAX: isize> CheckedDiv for Bounded<MIN, MAX>

Available on crate feature num-traits02 only.

fn checked_div(&self, v: &Self) -> Option<Self>

Divides two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl<const MIN: isize, const MAX: isize> CheckedMul for Bounded<MIN, MAX>

Available on crate feature num-traits02 only.

fn checked_mul(&self, v: &Self) -> Option<Self>

Multiplies two numbers, checking for underflow or overflow. If underflow or overflow happens, None is returned.

impl<const MIN: isize, const MAX: isize> CheckedNeg for Bounded<MIN, MAX>

Available on crate feature num-traits02 only.

fn checked_neg(&self) -> Option<Self>

Negates a number, returning None for results that can’t be represented, like signed MIN values that can’t be positive, or non-zero unsigned values that can’t be negative.

impl<const MIN: isize, const MAX: isize> CheckedRem for Bounded<MIN, MAX>

Available on crate feature num-traits02 only.

fn checked_rem(&self, v: &Self) -> Option<Self>

Finds the remainder of dividing two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl<const MIN: isize, const MAX: isize> CheckedShl for Bounded<MIN, MAX>

Available on crate feature num-traits02 only.

fn checked_shl(&self, v: u32) -> Option<Self>

Checked shift left. Computes self << rhs, returning None if rhs is larger than or equal to the number of bits in self.

impl<const MIN: isize, const MAX: isize> CheckedShr for Bounded<MIN, MAX>

Available on crate feature num-traits02 only.

fn checked_shr(&self, v: u32) -> Option<Self>

Checked shift right. Computes self >> rhs, returning None if rhs is larger than or equal to the number of bits in self.

impl<const MIN: isize, const MAX: isize> CheckedSub for Bounded<MIN, MAX>

Available on crate feature num-traits02 only.

fn checked_sub(&self, v: &Self) -> Option<Self>

Subtracts two numbers, checking for underflow. If underflow happens, None is returned.

impl<const MIN: isize, const MAX: isize> Clone for Bounded<MIN, MAX>

fn clone(&self) -> Bounded<MIN, MAX>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const MIN: isize, const MAX: isize> Contiguous for Bounded<MIN, MAX>

Available on crate feature bytemuck1 only.

type Int = isize

The primitive integer type with an identical representation to this type.

const MAX_VALUE: isize = MAX

The upper inclusive bound for valid instances of this type.

const MIN_VALUE: isize = MIN

The lower inclusive bound for valid instances of this type.

fn from_integer(value: Self::Int) -> Option<Self>

If value is within the range for valid instances of this type, returns Some(converted_value), otherwise, returns None.

fn into_integer(self) -> Self::Int

Perform the conversion from C into the underlying integral type. This mostly exists otherwise generic code would need unsafe for the value as integer

impl<const MIN: isize, const MAX: isize> Debug for Bounded<MIN, MAX>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, const MIN: isize, const MAX: isize> Deserialize<'de> for Bounded<MIN, MAX>

Available on crate feature serde1 only.

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<const MIN: isize, const MAX: isize> Display for Bounded<MIN, MAX>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const MIN: isize, const MAX: isize> Div<&Bounded<MIN, MAX>> for &isize

type Output = isize

The resulting type after applying the / operator.

fn div(self, rhs: &Bounded<MIN, MAX>) -> Self::Output

Performs the / operation.

impl<const MIN: isize, const MAX: isize> Div<&Bounded<MIN, MAX>> for isize

type Output = isize

The resulting type after applying the / operator.

fn div(self, rhs: &Bounded<MIN, MAX>) -> Self::Output

Performs the / operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Div<&Bounded<R_MIN, R_MAX>> for &Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the / operator.

fn div(self, rhs: &Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the / operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Div<&Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the / operator.

fn div(self, rhs: &Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the / operation.

impl<const MIN: isize, const MAX: isize> Div<&isize> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the / operator.

fn div(self, rhs: &isize) -> Self::Output

Performs the / operation.

impl<const MIN: isize, const MAX: isize> Div<&isize> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the / operator.

fn div(self, rhs: &isize) -> Self::Output

Performs the / operation.

impl<const MIN: isize, const MAX: isize> Div<Bounded<MIN, MAX>> for &isize

type Output = isize

The resulting type after applying the / operator.

fn div(self, rhs: Bounded<MIN, MAX>) -> Self::Output

Performs the / operation.

impl<const MIN: isize, const MAX: isize> Div<Bounded<MIN, MAX>> for isize

type Output = isize

The resulting type after applying the / operator.

fn div(self, rhs: Bounded<MIN, MAX>) -> Self::Output

Performs the / operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Div<Bounded<R_MIN, R_MAX>> for &Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the / operator.

fn div(self, rhs: Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the / operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Div<Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the / operator.

fn div(self, rhs: Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the / operation.

impl<const MIN: isize, const MAX: isize> Div<isize> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the / operator.

fn div(self, rhs: isize) -> Self::Output

Performs the / operation.

impl<const MIN: isize, const MAX: isize> Div<isize> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the / operator.

fn div(self, rhs: isize) -> Self::Output

Performs the / operation.

impl<const MIN: isize, const MAX: isize> DivAssign<&Bounded<MIN, MAX>> for isize

fn div_assign(&mut self, rhs: &Bounded<MIN, MAX>)

Performs the /= operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> DivAssign<&Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

fn div_assign(&mut self, rhs: &Bounded<R_MIN, R_MAX>)

Performs the /= operation.

impl<const MIN: isize, const MAX: isize> DivAssign<&isize> for Bounded<MIN, MAX>

fn div_assign(&mut self, rhs: &isize)

Performs the /= operation.

impl<const MIN: isize, const MAX: isize> DivAssign<Bounded<MIN, MAX>> for isize

fn div_assign(&mut self, rhs: Bounded<MIN, MAX>)

Performs the /= operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> DivAssign<Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

fn div_assign(&mut self, rhs: Bounded<R_MIN, R_MAX>)

Performs the /= operation.

impl<const MIN: isize, const MAX: isize> DivAssign<isize> for Bounded<MIN, MAX>

fn div_assign(&mut self, rhs: isize)

Performs the /= operation.

impl<const MIN: isize, const MAX: isize> From<Bounded<MIN, MAX>> for isize

fn from(bounded: Bounded<MIN, MAX>) -> Self

Converts to this type from the input type.

impl<const MIN: isize, const MAX: isize> FromPrimitive for Bounded<MIN, MAX>where isize: FromPrimitive,

Available on crate feature num-traits02 only.

fn from_i64(n: i64) -> Option<Self>

Converts an i64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u64(n: u64) -> Option<Self>

Converts an u64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_isize(n: isize) -> Option<Self>

Converts an isize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i8(n: i8) -> Option<Self>

Converts an i8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i16(n: i16) -> Option<Self>

Converts an i16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i32(n: i32) -> Option<Self>

Converts an i32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i128(n: i128) -> Option<Self>

Converts an i128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_usize(n: usize) -> Option<Self>

Converts a usize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u8(n: u8) -> Option<Self>

Converts an u8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u16(n: u16) -> Option<Self>

Converts an u16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u32(n: u32) -> Option<Self>

Converts an u32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u128(n: u128) -> Option<Self>

Converts an u128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f32(n: f32) -> Option<Self>

Converts a f32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f64(n: f64) -> Option<Self>

Converts a f64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

impl<const MIN: isize, const MAX: isize> FromStr for Bounded<MIN, MAX>

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<const MIN: isize, const MAX: isize> Hash for Bounded<MIN, MAX>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const MIN: isize, const MAX: isize> LowerExp for Bounded<MIN, MAX>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const MIN: isize, const MAX: isize> LowerHex for Bounded<MIN, MAX>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const MIN: isize, const MAX: isize> Mul<&Bounded<MIN, MAX>> for &isize

type Output = isize

The resulting type after applying the * operator.

fn mul(self, rhs: &Bounded<MIN, MAX>) -> Self::Output

Performs the * operation.

impl<const MIN: isize, const MAX: isize> Mul<&Bounded<MIN, MAX>> for isize

type Output = isize

The resulting type after applying the * operator.

fn mul(self, rhs: &Bounded<MIN, MAX>) -> Self::Output

Performs the * operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Mul<&Bounded<R_MIN, R_MAX>> for &Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the * operator.

fn mul(self, rhs: &Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the * operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Mul<&Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the * operator.

fn mul(self, rhs: &Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the * operation.

impl<const MIN: isize, const MAX: isize> Mul<&isize> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the * operator.

fn mul(self, rhs: &isize) -> Self::Output

Performs the * operation.

impl<const MIN: isize, const MAX: isize> Mul<&isize> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the * operator.

fn mul(self, rhs: &isize) -> Self::Output

Performs the * operation.

impl<const MIN: isize, const MAX: isize> Mul<Bounded<MIN, MAX>> for &isize

type Output = isize

The resulting type after applying the * operator.

fn mul(self, rhs: Bounded<MIN, MAX>) -> Self::Output

Performs the * operation.

impl<const MIN: isize, const MAX: isize> Mul<Bounded<MIN, MAX>> for isize

type Output = isize

The resulting type after applying the * operator.

fn mul(self, rhs: Bounded<MIN, MAX>) -> Self::Output

Performs the * operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Mul<Bounded<R_MIN, R_MAX>> for &Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the * operator.

fn mul(self, rhs: Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the * operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Mul<Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the * operator.

fn mul(self, rhs: Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the * operation.

impl<const MIN: isize, const MAX: isize> Mul<isize> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the * operator.

fn mul(self, rhs: isize) -> Self::Output

Performs the * operation.

impl<const MIN: isize, const MAX: isize> Mul<isize> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the * operator.

fn mul(self, rhs: isize) -> Self::Output

Performs the * operation.

impl<A, B, const MIN: isize, const MAX: isize> MulAdd<A, B> for Bounded<MIN, MAX>where isize: MulAdd<A, B, Output = isize>,

Available on crate feature num-traits02 only.

type Output = isize

The resulting type after applying the fused multiply-add.

fn mul_add(self, a: A, b: B) -> Self::Output

Performs the fused multiply-add operation.

impl<const MIN: isize, const MAX: isize> MulAssign<&Bounded<MIN, MAX>> for isize

fn mul_assign(&mut self, rhs: &Bounded<MIN, MAX>)

Performs the *= operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> MulAssign<&Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

fn mul_assign(&mut self, rhs: &Bounded<R_MIN, R_MAX>)

Performs the *= operation.

impl<const MIN: isize, const MAX: isize> MulAssign<&isize> for Bounded<MIN, MAX>

fn mul_assign(&mut self, rhs: &isize)

Performs the *= operation.

impl<const MIN: isize, const MAX: isize> MulAssign<Bounded<MIN, MAX>> for isize

fn mul_assign(&mut self, rhs: Bounded<MIN, MAX>)

Performs the *= operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> MulAssign<Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

fn mul_assign(&mut self, rhs: Bounded<R_MIN, R_MAX>)

Performs the *= operation.

impl<const MIN: isize, const MAX: isize> MulAssign<isize> for Bounded<MIN, MAX>

fn mul_assign(&mut self, rhs: isize)

Performs the *= operation.

impl<const MIN: isize, const MAX: isize> Neg for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const MIN: isize, const MAX: isize> Neg for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const MIN: isize, const MAX: isize> Not for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const MIN: isize, const MAX: isize> Not for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const MIN: isize, const MAX: isize> NumCast for Bounded<MIN, MAX>where isize: NumCast,

Available on crate feature num-traits02 only.

fn from<T: ToPrimitive>(n: T) -> Option<Self>

Creates a number from another value that can be converted into a primitive via the ToPrimitive trait. If the source value cannot be represented by the target type, then None is returned.

impl<const MIN: isize, const MAX: isize> Octal for Bounded<MIN, MAX>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const MIN: isize, const MAX: isize> Ord for Bounded<MIN, MAX>

fn cmp(&self, other: &Bounded<MIN, MAX>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<const A_MIN: isize, const A_MAX: isize, const B_MIN: isize, const B_MAX: isize> PartialEq<Bounded<B_MIN, B_MAX>> for Bounded<A_MIN, A_MAX>

fn eq(&self, other: &Bounded<B_MIN, B_MAX>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const MIN: isize, const MAX: isize> PartialEq<Bounded<MIN, MAX>> for isize

fn eq(&self, other: &Bounded<MIN, MAX>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const MIN: isize, const MAX: isize> PartialEq<isize> for Bounded<MIN, MAX>

fn eq(&self, other: &isize) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const A_MIN: isize, const A_MAX: isize, const B_MIN: isize, const B_MAX: isize> PartialOrd<Bounded<B_MIN, B_MAX>> for Bounded<A_MIN, A_MAX>

fn partial_cmp(&self, other: &Bounded<B_MIN, B_MAX>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const MIN: isize, const MAX: isize> PartialOrd<Bounded<MIN, MAX>> for isize

fn partial_cmp(&self, other: &Bounded<MIN, MAX>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const MIN: isize, const MAX: isize> PartialOrd<isize> for Bounded<MIN, MAX>

fn partial_cmp(&self, other: &isize) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, const MIN: isize, const MAX: isize> Product<&'a Bounded<MIN, MAX>> for Bounded<MIN, MAX>

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, const MIN: isize, const MAX: isize> Product<&'a Bounded<MIN, MAX>> for isize

fn product<I: Iterator<Item = &'a Bounded<MIN, MAX>>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<const MIN: isize, const MAX: isize> Product<Bounded<MIN, MAX>> for Bounded<MIN, MAX>

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<const MIN: isize, const MAX: isize> Product<Bounded<MIN, MAX>> for isize

fn product<I: Iterator<Item = Bounded<MIN, MAX>>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<const MIN: isize, const MAX: isize> Rem<&Bounded<MIN, MAX>> for &isize

type Output = isize

The resulting type after applying the % operator.

fn rem(self, rhs: &Bounded<MIN, MAX>) -> Self::Output

Performs the % operation.

impl<const MIN: isize, const MAX: isize> Rem<&Bounded<MIN, MAX>> for isize

type Output = isize

The resulting type after applying the % operator.

fn rem(self, rhs: &Bounded<MIN, MAX>) -> Self::Output

Performs the % operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Rem<&Bounded<R_MIN, R_MAX>> for &Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the % operator.

fn rem(self, rhs: &Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the % operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Rem<&Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the % operator.

fn rem(self, rhs: &Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the % operation.

impl<const MIN: isize, const MAX: isize> Rem<&isize> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the % operator.

fn rem(self, rhs: &isize) -> Self::Output

Performs the % operation.

impl<const MIN: isize, const MAX: isize> Rem<&isize> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the % operator.

fn rem(self, rhs: &isize) -> Self::Output

Performs the % operation.

impl<const MIN: isize, const MAX: isize> Rem<Bounded<MIN, MAX>> for &isize

type Output = isize

The resulting type after applying the % operator.

fn rem(self, rhs: Bounded<MIN, MAX>) -> Self::Output

Performs the % operation.

impl<const MIN: isize, const MAX: isize> Rem<Bounded<MIN, MAX>> for isize

type Output = isize

The resulting type after applying the % operator.

fn rem(self, rhs: Bounded<MIN, MAX>) -> Self::Output

Performs the % operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Rem<Bounded<R_MIN, R_MAX>> for &Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the % operator.

fn rem(self, rhs: Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the % operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Rem<Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the % operator.

fn rem(self, rhs: Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the % operation.

impl<const MIN: isize, const MAX: isize> Rem<isize> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the % operator.

fn rem(self, rhs: isize) -> Self::Output

Performs the % operation.

impl<const MIN: isize, const MAX: isize> Rem<isize> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the % operator.

fn rem(self, rhs: isize) -> Self::Output

Performs the % operation.

impl<const MIN: isize, const MAX: isize> RemAssign<&Bounded<MIN, MAX>> for isize

fn rem_assign(&mut self, rhs: &Bounded<MIN, MAX>)

Performs the %= operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> RemAssign<&Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

fn rem_assign(&mut self, rhs: &Bounded<R_MIN, R_MAX>)

Performs the %= operation.

impl<const MIN: isize, const MAX: isize> RemAssign<&isize> for Bounded<MIN, MAX>

fn rem_assign(&mut self, rhs: &isize)

Performs the %= operation.

impl<const MIN: isize, const MAX: isize> RemAssign<Bounded<MIN, MAX>> for isize

fn rem_assign(&mut self, rhs: Bounded<MIN, MAX>)

Performs the %= operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> RemAssign<Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

fn rem_assign(&mut self, rhs: Bounded<R_MIN, R_MAX>)

Performs the %= operation.

impl<const MIN: isize, const MAX: isize> RemAssign<isize> for Bounded<MIN, MAX>

fn rem_assign(&mut self, rhs: isize)

Performs the %= operation.

impl<const MIN: isize, const MAX: isize> SaturatingAdd for Bounded<MIN, MAX>

Available on crate feature num-traits02 only.

fn saturating_add(&self, v: &Self) -> Self

Saturating addition. Computes self + other, saturating at the relevant high or low boundary of the type.

impl<const MIN: isize, const MAX: isize> SaturatingMul for Bounded<MIN, MAX>

Available on crate feature num-traits02 only.

fn saturating_mul(&self, v: &Self) -> Self

Saturating multiplication. Computes self * other, saturating at the relevant high or low boundary of the type.

impl<const MIN: isize, const MAX: isize> SaturatingSub for Bounded<MIN, MAX>

Available on crate feature num-traits02 only.

fn saturating_sub(&self, v: &Self) -> Self

Saturating subtraction. Computes self - other, saturating at the relevant high or low boundary of the type.

impl<const MIN: isize, const MAX: isize> Serialize for Bounded<MIN, MAX>

Available on crate feature serde1 only.

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<const MIN: isize, const MAX: isize> Shl<&Bounded<MIN, MAX>> for &isize

type Output = isize

The resulting type after applying the << operator.

fn shl(self, rhs: &Bounded<MIN, MAX>) -> Self::Output

Performs the << operation.

impl<const MIN: isize, const MAX: isize> Shl<&Bounded<MIN, MAX>> for isize

type Output = isize

The resulting type after applying the << operator.

fn shl(self, rhs: &Bounded<MIN, MAX>) -> Self::Output

Performs the << operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Shl<&Bounded<R_MIN, R_MAX>> for &Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the << operator.

fn shl(self, rhs: &Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the << operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Shl<&Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the << operator.

fn shl(self, rhs: &Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the << operation.

impl<const MIN: isize, const MAX: isize> Shl<&isize> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the << operator.

fn shl(self, rhs: &isize) -> Self::Output

Performs the << operation.

impl<const MIN: isize, const MAX: isize> Shl<&isize> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the << operator.

fn shl(self, rhs: &isize) -> Self::Output

Performs the << operation.

impl<const MIN: isize, const MAX: isize> Shl<&u32> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the << operator.

fn shl(self, rhs: &u32) -> Self::Output

Performs the << operation.

impl<const MIN: isize, const MAX: isize> Shl<&u32> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the << operator.

fn shl(self, rhs: &u32) -> Self::Output

Performs the << operation.

impl<const MIN: isize, const MAX: isize> Shl<Bounded<MIN, MAX>> for &isize

type Output = isize

The resulting type after applying the << operator.

fn shl(self, rhs: Bounded<MIN, MAX>) -> Self::Output

Performs the << operation.

impl<const MIN: isize, const MAX: isize> Shl<Bounded<MIN, MAX>> for isize

type Output = isize

The resulting type after applying the << operator.

fn shl(self, rhs: Bounded<MIN, MAX>) -> Self::Output

Performs the << operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Shl<Bounded<R_MIN, R_MAX>> for &Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the << operator.

fn shl(self, rhs: Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the << operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Shl<Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the << operator.

fn shl(self, rhs: Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the << operation.

impl<const MIN: isize, const MAX: isize> Shl<isize> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the << operator.

fn shl(self, rhs: isize) -> Self::Output

Performs the << operation.

impl<const MIN: isize, const MAX: isize> Shl<isize> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the << operator.

fn shl(self, rhs: isize) -> Self::Output

Performs the << operation.

impl<const MIN: isize, const MAX: isize> Shl<u32> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> Self::Output

Performs the << operation.

impl<const MIN: isize, const MAX: isize> Shl<u32> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> Self::Output

Performs the << operation.

impl<const MIN: isize, const MAX: isize> ShlAssign<&Bounded<MIN, MAX>> for isize

fn shl_assign(&mut self, rhs: &Bounded<MIN, MAX>)

Performs the <<= operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> ShlAssign<&Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

fn shl_assign(&mut self, rhs: &Bounded<R_MIN, R_MAX>)

Performs the <<= operation.

impl<const MIN: isize, const MAX: isize> ShlAssign<&isize> for Bounded<MIN, MAX>

fn shl_assign(&mut self, rhs: &isize)

Performs the <<= operation.

impl<const MIN: isize, const MAX: isize> ShlAssign<&u32> for Bounded<MIN, MAX>

fn shl_assign(&mut self, rhs: &u32)

Performs the <<= operation.

impl<const MIN: isize, const MAX: isize> ShlAssign<Bounded<MIN, MAX>> for isize

fn shl_assign(&mut self, rhs: Bounded<MIN, MAX>)

Performs the <<= operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> ShlAssign<Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

fn shl_assign(&mut self, rhs: Bounded<R_MIN, R_MAX>)

Performs the <<= operation.

impl<const MIN: isize, const MAX: isize> ShlAssign<isize> for Bounded<MIN, MAX>

fn shl_assign(&mut self, rhs: isize)

Performs the <<= operation.

impl<const MIN: isize, const MAX: isize> ShlAssign<u32> for Bounded<MIN, MAX>

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl<const MIN: isize, const MAX: isize> Shr<&Bounded<MIN, MAX>> for &isize

type Output = isize

The resulting type after applying the >> operator.

fn shr(self, rhs: &Bounded<MIN, MAX>) -> Self::Output

Performs the >> operation.

impl<const MIN: isize, const MAX: isize> Shr<&Bounded<MIN, MAX>> for isize

type Output = isize

The resulting type after applying the >> operator.

fn shr(self, rhs: &Bounded<MIN, MAX>) -> Self::Output

Performs the >> operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Shr<&Bounded<R_MIN, R_MAX>> for &Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the >> operator.

fn shr(self, rhs: &Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the >> operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Shr<&Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the >> operator.

fn shr(self, rhs: &Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the >> operation.

impl<const MIN: isize, const MAX: isize> Shr<&isize> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the >> operator.

fn shr(self, rhs: &isize) -> Self::Output

Performs the >> operation.

impl<const MIN: isize, const MAX: isize> Shr<&isize> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the >> operator.

fn shr(self, rhs: &isize) -> Self::Output

Performs the >> operation.

impl<const MIN: isize, const MAX: isize> Shr<&u32> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u32) -> Self::Output

Performs the >> operation.

impl<const MIN: isize, const MAX: isize> Shr<&u32> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u32) -> Self::Output

Performs the >> operation.

impl<const MIN: isize, const MAX: isize> Shr<Bounded<MIN, MAX>> for &isize

type Output = isize

The resulting type after applying the >> operator.

fn shr(self, rhs: Bounded<MIN, MAX>) -> Self::Output

Performs the >> operation.

impl<const MIN: isize, const MAX: isize> Shr<Bounded<MIN, MAX>> for isize

type Output = isize

The resulting type after applying the >> operator.

fn shr(self, rhs: Bounded<MIN, MAX>) -> Self::Output

Performs the >> operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Shr<Bounded<R_MIN, R_MAX>> for &Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the >> operator.

fn shr(self, rhs: Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the >> operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Shr<Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the >> operator.

fn shr(self, rhs: Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the >> operation.

impl<const MIN: isize, const MAX: isize> Shr<isize> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the >> operator.

fn shr(self, rhs: isize) -> Self::Output

Performs the >> operation.

impl<const MIN: isize, const MAX: isize> Shr<isize> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the >> operator.

fn shr(self, rhs: isize) -> Self::Output

Performs the >> operation.

impl<const MIN: isize, const MAX: isize> Shr<u32> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> Self::Output

Performs the >> operation.

impl<const MIN: isize, const MAX: isize> Shr<u32> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> Self::Output

Performs the >> operation.

impl<const MIN: isize, const MAX: isize> ShrAssign<&Bounded<MIN, MAX>> for isize

fn shr_assign(&mut self, rhs: &Bounded<MIN, MAX>)

Performs the >>= operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> ShrAssign<&Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

fn shr_assign(&mut self, rhs: &Bounded<R_MIN, R_MAX>)

Performs the >>= operation.

impl<const MIN: isize, const MAX: isize> ShrAssign<&isize> for Bounded<MIN, MAX>

fn shr_assign(&mut self, rhs: &isize)

Performs the >>= operation.

impl<const MIN: isize, const MAX: isize> ShrAssign<&u32> for Bounded<MIN, MAX>

fn shr_assign(&mut self, rhs: &u32)

Performs the >>= operation.

impl<const MIN: isize, const MAX: isize> ShrAssign<Bounded<MIN, MAX>> for isize

fn shr_assign(&mut self, rhs: Bounded<MIN, MAX>)

Performs the >>= operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> ShrAssign<Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

fn shr_assign(&mut self, rhs: Bounded<R_MIN, R_MAX>)

Performs the >>= operation.

impl<const MIN: isize, const MAX: isize> ShrAssign<isize> for Bounded<MIN, MAX>

fn shr_assign(&mut self, rhs: isize)

Performs the >>= operation.

impl<const MIN: isize, const MAX: isize> ShrAssign<u32> for Bounded<MIN, MAX>

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl<const MIN: isize, const MAX: isize> Step for Bounded<MIN, MAX>

Available on crate feature step_trait only.

fn steps_between(start: &Self, end: &Self) -> Option<usize>

🔬This is a nightly-only experimental API. (step_trait)

Returns the number of successor steps required to get from start to end.

fn forward_checked(start: Self, count: usize) -> Option<Self>

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the successor of self count times.

fn backward_checked(start: Self, count: usize) -> Option<Self>

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the predecessor of self count times.

fn forward(start: Self, count: usize) -> Self

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the successor of self count times.

unsafe fn forward_unchecked(start: Self, count: usize) -> Self

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the successor of self count times.

fn backward(start: Self, count: usize) -> Self

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the predecessor of self count times.

unsafe fn backward_unchecked(start: Self, count: usize) -> Self

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the predecessor of self count times.

impl<const MIN: isize, const MAX: isize> Sub<&Bounded<MIN, MAX>> for &isize

type Output = isize

The resulting type after applying the - operator.

fn sub(self, rhs: &Bounded<MIN, MAX>) -> Self::Output

Performs the - operation.

impl<const MIN: isize, const MAX: isize> Sub<&Bounded<MIN, MAX>> for isize

type Output = isize

The resulting type after applying the - operator.

fn sub(self, rhs: &Bounded<MIN, MAX>) -> Self::Output

Performs the - operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Sub<&Bounded<R_MIN, R_MAX>> for &Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the - operator.

fn sub(self, rhs: &Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the - operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Sub<&Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the - operator.

fn sub(self, rhs: &Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the - operation.

impl<const MIN: isize, const MAX: isize> Sub<&isize> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the - operator.

fn sub(self, rhs: &isize) -> Self::Output

Performs the - operation.

impl<const MIN: isize, const MAX: isize> Sub<&isize> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the - operator.

fn sub(self, rhs: &isize) -> Self::Output

Performs the - operation.

impl<const MIN: isize, const MAX: isize> Sub<Bounded<MIN, MAX>> for &isize

type Output = isize

The resulting type after applying the - operator.

fn sub(self, rhs: Bounded<MIN, MAX>) -> Self::Output

Performs the - operation.

impl<const MIN: isize, const MAX: isize> Sub<Bounded<MIN, MAX>> for isize

type Output = isize

The resulting type after applying the - operator.

fn sub(self, rhs: Bounded<MIN, MAX>) -> Self::Output

Performs the - operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Sub<Bounded<R_MIN, R_MAX>> for &Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the - operator.

fn sub(self, rhs: Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the - operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> Sub<Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

type Output = Bounded<L_MIN, L_MAX>

The resulting type after applying the - operator.

fn sub(self, rhs: Bounded<R_MIN, R_MAX>) -> Self::Output

Performs the - operation.

impl<const MIN: isize, const MAX: isize> Sub<isize> for &Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> Self::Output

Performs the - operation.

impl<const MIN: isize, const MAX: isize> Sub<isize> for Bounded<MIN, MAX>

type Output = Bounded<MIN, MAX>

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> Self::Output

Performs the - operation.

impl<const MIN: isize, const MAX: isize> SubAssign<&Bounded<MIN, MAX>> for isize

fn sub_assign(&mut self, rhs: &Bounded<MIN, MAX>)

Performs the -= operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> SubAssign<&Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

fn sub_assign(&mut self, rhs: &Bounded<R_MIN, R_MAX>)

Performs the -= operation.

impl<const MIN: isize, const MAX: isize> SubAssign<&isize> for Bounded<MIN, MAX>

fn sub_assign(&mut self, rhs: &isize)

Performs the -= operation.

impl<const MIN: isize, const MAX: isize> SubAssign<Bounded<MIN, MAX>> for isize

fn sub_assign(&mut self, rhs: Bounded<MIN, MAX>)

Performs the -= operation.

impl<const L_MIN: isize, const L_MAX: isize, const R_MIN: isize, const R_MAX: isize> SubAssign<Bounded<R_MIN, R_MAX>> for Bounded<L_MIN, L_MAX>

fn sub_assign(&mut self, rhs: Bounded<R_MIN, R_MAX>)

Performs the -= operation.

impl<const MIN: isize, const MAX: isize> SubAssign<isize> for Bounded<MIN, MAX>

fn sub_assign(&mut self, rhs: isize)

Performs the -= operation.

impl<'a, const MIN: isize, const MAX: isize> Sum<&'a Bounded<MIN, MAX>> for Bounded<MIN, MAX>

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, const MIN: isize, const MAX: isize> Sum<&'a Bounded<MIN, MAX>> for isize

fn sum<I: Iterator<Item = &'a Bounded<MIN, MAX>>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<const MIN: isize, const MAX: isize> Sum<Bounded<MIN, MAX>> for Bounded<MIN, MAX>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<const MIN: isize, const MAX: isize> Sum<Bounded<MIN, MAX>> for isize

fn sum<I: Iterator<Item = Bounded<MIN, MAX>>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<const MIN: isize, const MAX: isize> ToPrimitive for Bounded<MIN, MAX>where isize: ToPrimitive,

Available on crate feature num-traits02 only.

fn to_i64(&self) -> Option<i64>

Converts the value of self to an i64. If the value cannot be represented by an i64, then None is returned.

fn to_u64(&self) -> Option<u64>

Converts the value of self to a u64. If the value cannot be represented by a u64, then None is returned.

fn to_isize(&self) -> Option<isize>

Converts the value of self to an isize. If the value cannot be represented by an isize, then None is returned.

fn to_i8(&self) -> Option<i8>

Converts the value of self to an i8. If the value cannot be represented by an i8, then None is returned.

fn to_i16(&self) -> Option<i16>

Converts the value of self to an i16. If the value cannot be represented by an i16, then None is returned.

fn to_i32(&self) -> Option<i32>

Converts the value of self to an i32. If the value cannot be represented by an i32, then None is returned.

fn to_i128(&self) -> Option<i128>

Converts the value of self to an i128. If the value cannot be represented by an i128 (i64 under the default implementation), then None is returned.

fn to_usize(&self) -> Option<usize>

Converts the value of self to a usize. If the value cannot be represented by a usize, then None is returned.

fn to_u8(&self) -> Option<u8>

Converts the value of self to a u8. If the value cannot be represented by a u8, then None is returned.

fn to_u16(&self) -> Option<u16>

Converts the value of self to a u16. If the value cannot be represented by a u16, then None is returned.

fn to_u32(&self) -> Option<u32>

Converts the value of self to a u32. If the value cannot be represented by a u32, then None is returned.

fn to_u128(&self) -> Option<u128>

Converts the value of self to a u128. If the value cannot be represented by a u128 (u64 under the default implementation), then None is returned.

fn to_f32(&self) -> Option<f32>

Converts the value of self to an f32. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f32.

fn to_f64(&self) -> Option<f64>

Converts the value of self to an f64. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f64.

impl<const MIN: isize, const MAX: isize> UpperExp for Bounded<MIN, MAX>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const MIN: isize, const MAX: isize> UpperHex for Bounded<MIN, MAX>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const MIN: isize, const MAX: isize> Copy for Bounded<MIN, MAX>

impl<const MIN: isize, const MAX: isize> Eq for Bounded<MIN, MAX>

impl<const MIN: isize, const MAX: isize> StructuralEq for Bounded<MIN, MAX>