Struct otter_api_tests::Wrapping 1.0.0[−][src]
#[repr(transparent)]pub struct Wrapping<T>(pub T);
Expand description
Provides intentionally-wrapped arithmetic on T
.
Operations like +
on u32
values are intended to never overflow,
and in some debug configurations overflow is detected and results
in a panic. While most arithmetic falls into this category, some
code explicitly expects and relies upon modular arithmetic (e.g.,
hashing).
Wrapping arithmetic can be achieved either through methods like
wrapping_add
, or through the Wrapping<T>
type, which says that
all standard arithmetic operations on the underlying value are
intended to have wrapping semantics.
The underlying value can be retrieved through the .0
index of the
Wrapping
tuple.
Examples
use std::num::Wrapping; let zero = Wrapping(0u32); let one = Wrapping(1u32); assert_eq!(u32::MAX, (zero - one).0);
Implementations
impl Wrapping<usize>
[src]
impl Wrapping<usize>
[src]pub const MIN: Wrapping<usize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MIN: Wrapping<usize>
[src]wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<usize>>::MIN, Wrapping(usize::MIN));
pub const MAX: Wrapping<usize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MAX: Wrapping<usize>
[src]wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<usize>>::MAX, Wrapping(usize::MAX));
pub const BITS: u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const BITS: u32
[src]wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<usize>>::BITS, usize::BITS);
pub const fn count_ones(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_ones(self) -> u32
[src]wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100usize); assert_eq!(n.count_ones(), 3);
pub const fn count_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0usize).count_zeros(), 0);
pub const fn trailing_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn trailing_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000usize); assert_eq!(n.trailing_zeros(), 3);
pub const fn rotate_left(self, n: u32) -> Wrapping<usize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_left(self, n: u32) -> Wrapping<usize>
[src]wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
pub const fn rotate_right(self, n: u32) -> Wrapping<usize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_right(self, n: u32) -> Wrapping<usize>
[src]wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
pub const fn swap_bytes(self) -> Wrapping<usize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn swap_bytes(self) -> Wrapping<usize>
[src]wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
#[must_use]pub const fn reverse_bits(self) -> Wrapping<usize>
1.37.0 (const: 1.37.0)[src]
#[must_use]pub const fn reverse_bits(self) -> Wrapping<usize>
1.37.0 (const: 1.37.0)[src]Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
pub const fn from_be(x: Wrapping<usize>) -> Wrapping<usize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_be(x: Wrapping<usize>) -> Wrapping<usize>
[src]wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ausize); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<usize>>::from_be(n), n) } else { assert_eq!(<Wrapping<usize>>::from_be(n), n.swap_bytes()) }
pub const fn from_le(x: Wrapping<usize>) -> Wrapping<usize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_le(x: Wrapping<usize>) -> Wrapping<usize>
[src]wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ausize); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<usize>>::from_le(n), n) } else { assert_eq!(<Wrapping<usize>>::from_le(n), n.swap_bytes()) }
pub const fn to_be(self) -> Wrapping<usize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_be(self) -> Wrapping<usize>
[src]wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ausize); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
pub const fn to_le(self) -> Wrapping<usize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_le(self) -> Wrapping<usize>
[src]wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ausize); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
pub fn pow(self, exp: u32) -> Wrapping<usize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn pow(self, exp: u32) -> Wrapping<usize>
[src]wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3usize).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
impl Wrapping<u8>
[src]
impl Wrapping<u8>
[src]pub const MIN: Wrapping<u8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MIN: Wrapping<u8>
[src]wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u8>>::MIN, Wrapping(u8::MIN));
pub const MAX: Wrapping<u8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MAX: Wrapping<u8>
[src]wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u8>>::MAX, Wrapping(u8::MAX));
pub const BITS: u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const BITS: u32
[src]wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u8>>::BITS, u8::BITS);
pub const fn count_ones(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_ones(self) -> u32
[src]wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100u8); assert_eq!(n.count_ones(), 3);
pub const fn count_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0u8).count_zeros(), 0);
pub const fn trailing_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn trailing_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000u8); assert_eq!(n.trailing_zeros(), 3);
pub const fn rotate_left(self, n: u32) -> Wrapping<u8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_left(self, n: u32) -> Wrapping<u8>
[src]wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
pub const fn rotate_right(self, n: u32) -> Wrapping<u8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_right(self, n: u32) -> Wrapping<u8>
[src]wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
pub const fn swap_bytes(self) -> Wrapping<u8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn swap_bytes(self) -> Wrapping<u8>
[src]wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
#[must_use]pub const fn reverse_bits(self) -> Wrapping<u8>
1.37.0 (const: 1.37.0)[src]
#[must_use]pub const fn reverse_bits(self) -> Wrapping<u8>
1.37.0 (const: 1.37.0)[src]Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
pub const fn from_be(x: Wrapping<u8>) -> Wrapping<u8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_be(x: Wrapping<u8>) -> Wrapping<u8>
[src]wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au8); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<u8>>::from_be(n), n) } else { assert_eq!(<Wrapping<u8>>::from_be(n), n.swap_bytes()) }
pub const fn from_le(x: Wrapping<u8>) -> Wrapping<u8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_le(x: Wrapping<u8>) -> Wrapping<u8>
[src]wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au8); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<u8>>::from_le(n), n) } else { assert_eq!(<Wrapping<u8>>::from_le(n), n.swap_bytes()) }
pub const fn to_be(self) -> Wrapping<u8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_be(self) -> Wrapping<u8>
[src]wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au8); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
pub const fn to_le(self) -> Wrapping<u8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_le(self) -> Wrapping<u8>
[src]wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au8); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
pub fn pow(self, exp: u32) -> Wrapping<u8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn pow(self, exp: u32) -> Wrapping<u8>
[src]wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3u8).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
impl Wrapping<u16>
[src]
impl Wrapping<u16>
[src]pub const MIN: Wrapping<u16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MIN: Wrapping<u16>
[src]wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u16>>::MIN, Wrapping(u16::MIN));
pub const MAX: Wrapping<u16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MAX: Wrapping<u16>
[src]wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u16>>::MAX, Wrapping(u16::MAX));
pub const BITS: u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const BITS: u32
[src]wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u16>>::BITS, u16::BITS);
pub const fn count_ones(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_ones(self) -> u32
[src]wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100u16); assert_eq!(n.count_ones(), 3);
pub const fn count_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0u16).count_zeros(), 0);
pub const fn trailing_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn trailing_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000u16); assert_eq!(n.trailing_zeros(), 3);
pub const fn rotate_left(self, n: u32) -> Wrapping<u16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_left(self, n: u32) -> Wrapping<u16>
[src]wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
pub const fn rotate_right(self, n: u32) -> Wrapping<u16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_right(self, n: u32) -> Wrapping<u16>
[src]wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
pub const fn swap_bytes(self) -> Wrapping<u16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn swap_bytes(self) -> Wrapping<u16>
[src]wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
#[must_use]pub const fn reverse_bits(self) -> Wrapping<u16>
1.37.0 (const: 1.37.0)[src]
#[must_use]pub const fn reverse_bits(self) -> Wrapping<u16>
1.37.0 (const: 1.37.0)[src]Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
pub const fn from_be(x: Wrapping<u16>) -> Wrapping<u16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_be(x: Wrapping<u16>) -> Wrapping<u16>
[src]wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au16); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<u16>>::from_be(n), n) } else { assert_eq!(<Wrapping<u16>>::from_be(n), n.swap_bytes()) }
pub const fn from_le(x: Wrapping<u16>) -> Wrapping<u16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_le(x: Wrapping<u16>) -> Wrapping<u16>
[src]wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au16); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<u16>>::from_le(n), n) } else { assert_eq!(<Wrapping<u16>>::from_le(n), n.swap_bytes()) }
pub const fn to_be(self) -> Wrapping<u16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_be(self) -> Wrapping<u16>
[src]wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au16); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
pub const fn to_le(self) -> Wrapping<u16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_le(self) -> Wrapping<u16>
[src]wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au16); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
pub fn pow(self, exp: u32) -> Wrapping<u16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn pow(self, exp: u32) -> Wrapping<u16>
[src]wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3u16).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
impl Wrapping<u32>
[src]
impl Wrapping<u32>
[src]pub const MIN: Wrapping<u32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MIN: Wrapping<u32>
[src]wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u32>>::MIN, Wrapping(u32::MIN));
pub const MAX: Wrapping<u32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MAX: Wrapping<u32>
[src]wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u32>>::MAX, Wrapping(u32::MAX));
pub const BITS: u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const BITS: u32
[src]wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u32>>::BITS, u32::BITS);
pub const fn count_ones(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_ones(self) -> u32
[src]wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100u32); assert_eq!(n.count_ones(), 3);
pub const fn count_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0u32).count_zeros(), 0);
pub const fn trailing_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn trailing_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000u32); assert_eq!(n.trailing_zeros(), 3);
pub const fn rotate_left(self, n: u32) -> Wrapping<u32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_left(self, n: u32) -> Wrapping<u32>
[src]wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
pub const fn rotate_right(self, n: u32) -> Wrapping<u32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_right(self, n: u32) -> Wrapping<u32>
[src]wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
pub const fn swap_bytes(self) -> Wrapping<u32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn swap_bytes(self) -> Wrapping<u32>
[src]wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
#[must_use]pub const fn reverse_bits(self) -> Wrapping<u32>
1.37.0 (const: 1.37.0)[src]
#[must_use]pub const fn reverse_bits(self) -> Wrapping<u32>
1.37.0 (const: 1.37.0)[src]Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
pub const fn from_be(x: Wrapping<u32>) -> Wrapping<u32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_be(x: Wrapping<u32>) -> Wrapping<u32>
[src]wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au32); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<u32>>::from_be(n), n) } else { assert_eq!(<Wrapping<u32>>::from_be(n), n.swap_bytes()) }
pub const fn from_le(x: Wrapping<u32>) -> Wrapping<u32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_le(x: Wrapping<u32>) -> Wrapping<u32>
[src]wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au32); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<u32>>::from_le(n), n) } else { assert_eq!(<Wrapping<u32>>::from_le(n), n.swap_bytes()) }
pub const fn to_be(self) -> Wrapping<u32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_be(self) -> Wrapping<u32>
[src]wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au32); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
pub const fn to_le(self) -> Wrapping<u32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_le(self) -> Wrapping<u32>
[src]wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au32); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
pub fn pow(self, exp: u32) -> Wrapping<u32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn pow(self, exp: u32) -> Wrapping<u32>
[src]wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3u32).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
impl Wrapping<u64>
[src]
impl Wrapping<u64>
[src]pub const MIN: Wrapping<u64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MIN: Wrapping<u64>
[src]wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u64>>::MIN, Wrapping(u64::MIN));
pub const MAX: Wrapping<u64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MAX: Wrapping<u64>
[src]wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u64>>::MAX, Wrapping(u64::MAX));
pub const BITS: u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const BITS: u32
[src]wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u64>>::BITS, u64::BITS);
pub const fn count_ones(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_ones(self) -> u32
[src]wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100u64); assert_eq!(n.count_ones(), 3);
pub const fn count_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0u64).count_zeros(), 0);
pub const fn trailing_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn trailing_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000u64); assert_eq!(n.trailing_zeros(), 3);
pub const fn rotate_left(self, n: u32) -> Wrapping<u64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_left(self, n: u32) -> Wrapping<u64>
[src]wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
pub const fn rotate_right(self, n: u32) -> Wrapping<u64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_right(self, n: u32) -> Wrapping<u64>
[src]wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
pub const fn swap_bytes(self) -> Wrapping<u64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn swap_bytes(self) -> Wrapping<u64>
[src]wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
#[must_use]pub const fn reverse_bits(self) -> Wrapping<u64>
1.37.0 (const: 1.37.0)[src]
#[must_use]pub const fn reverse_bits(self) -> Wrapping<u64>
1.37.0 (const: 1.37.0)[src]Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
pub const fn from_be(x: Wrapping<u64>) -> Wrapping<u64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_be(x: Wrapping<u64>) -> Wrapping<u64>
[src]wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au64); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<u64>>::from_be(n), n) } else { assert_eq!(<Wrapping<u64>>::from_be(n), n.swap_bytes()) }
pub const fn from_le(x: Wrapping<u64>) -> Wrapping<u64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_le(x: Wrapping<u64>) -> Wrapping<u64>
[src]wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au64); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<u64>>::from_le(n), n) } else { assert_eq!(<Wrapping<u64>>::from_le(n), n.swap_bytes()) }
pub const fn to_be(self) -> Wrapping<u64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_be(self) -> Wrapping<u64>
[src]wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au64); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
pub const fn to_le(self) -> Wrapping<u64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_le(self) -> Wrapping<u64>
[src]wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au64); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
pub fn pow(self, exp: u32) -> Wrapping<u64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn pow(self, exp: u32) -> Wrapping<u64>
[src]wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3u64).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
impl Wrapping<u128>
[src]
impl Wrapping<u128>
[src]pub const MIN: Wrapping<u128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MIN: Wrapping<u128>
[src]wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u128>>::MIN, Wrapping(u128::MIN));
pub const MAX: Wrapping<u128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MAX: Wrapping<u128>
[src]wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u128>>::MAX, Wrapping(u128::MAX));
pub const BITS: u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const BITS: u32
[src]wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<u128>>::BITS, u128::BITS);
pub const fn count_ones(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_ones(self) -> u32
[src]wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100u128); assert_eq!(n.count_ones(), 3);
pub const fn count_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0u128).count_zeros(), 0);
pub const fn trailing_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn trailing_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000u128); assert_eq!(n.trailing_zeros(), 3);
pub const fn rotate_left(self, n: u32) -> Wrapping<u128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_left(self, n: u32) -> Wrapping<u128>
[src]wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
pub const fn rotate_right(self, n: u32) -> Wrapping<u128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_right(self, n: u32) -> Wrapping<u128>
[src]wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
pub const fn swap_bytes(self) -> Wrapping<u128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn swap_bytes(self) -> Wrapping<u128>
[src]wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
#[must_use]pub const fn reverse_bits(self) -> Wrapping<u128>
1.37.0 (const: 1.37.0)[src]
#[must_use]pub const fn reverse_bits(self) -> Wrapping<u128>
1.37.0 (const: 1.37.0)[src]Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
pub const fn from_be(x: Wrapping<u128>) -> Wrapping<u128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_be(x: Wrapping<u128>) -> Wrapping<u128>
[src]wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au128); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<u128>>::from_be(n), n) } else { assert_eq!(<Wrapping<u128>>::from_be(n), n.swap_bytes()) }
pub const fn from_le(x: Wrapping<u128>) -> Wrapping<u128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_le(x: Wrapping<u128>) -> Wrapping<u128>
[src]wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au128); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<u128>>::from_le(n), n) } else { assert_eq!(<Wrapping<u128>>::from_le(n), n.swap_bytes()) }
pub const fn to_be(self) -> Wrapping<u128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_be(self) -> Wrapping<u128>
[src]wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au128); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
pub const fn to_le(self) -> Wrapping<u128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_le(self) -> Wrapping<u128>
[src]wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Au128); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
pub fn pow(self, exp: u32) -> Wrapping<u128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn pow(self, exp: u32) -> Wrapping<u128>
[src]wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3u128).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
impl Wrapping<isize>
[src]
impl Wrapping<isize>
[src]pub const MIN: Wrapping<isize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MIN: Wrapping<isize>
[src]wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<isize>>::MIN, Wrapping(isize::MIN));
pub const MAX: Wrapping<isize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MAX: Wrapping<isize>
[src]wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<isize>>::MAX, Wrapping(isize::MAX));
pub const BITS: u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const BITS: u32
[src]wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<isize>>::BITS, isize::BITS);
pub const fn count_ones(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_ones(self) -> u32
[src]wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100isize); assert_eq!(n.count_ones(), 3);
pub const fn count_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0isize).count_zeros(), 0);
pub const fn trailing_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn trailing_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000isize); assert_eq!(n.trailing_zeros(), 3);
pub const fn rotate_left(self, n: u32) -> Wrapping<isize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_left(self, n: u32) -> Wrapping<isize>
[src]wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
pub const fn rotate_right(self, n: u32) -> Wrapping<isize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_right(self, n: u32) -> Wrapping<isize>
[src]wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
pub const fn swap_bytes(self) -> Wrapping<isize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn swap_bytes(self) -> Wrapping<isize>
[src]wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
#[must_use]pub const fn reverse_bits(self) -> Wrapping<isize>
1.37.0 (const: 1.37.0)[src]
#[must_use]pub const fn reverse_bits(self) -> Wrapping<isize>
1.37.0 (const: 1.37.0)[src]Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
pub const fn from_be(x: Wrapping<isize>) -> Wrapping<isize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_be(x: Wrapping<isize>) -> Wrapping<isize>
[src]wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Aisize); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<isize>>::from_be(n), n) } else { assert_eq!(<Wrapping<isize>>::from_be(n), n.swap_bytes()) }
pub const fn from_le(x: Wrapping<isize>) -> Wrapping<isize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_le(x: Wrapping<isize>) -> Wrapping<isize>
[src]wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Aisize); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<isize>>::from_le(n), n) } else { assert_eq!(<Wrapping<isize>>::from_le(n), n.swap_bytes()) }
pub const fn to_be(self) -> Wrapping<isize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_be(self) -> Wrapping<isize>
[src]wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Aisize); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
pub const fn to_le(self) -> Wrapping<isize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_le(self) -> Wrapping<isize>
[src]wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Aisize); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
pub fn pow(self, exp: u32) -> Wrapping<isize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn pow(self, exp: u32) -> Wrapping<isize>
[src]wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3isize).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
impl Wrapping<i8>
[src]
impl Wrapping<i8>
[src]pub const MIN: Wrapping<i8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MIN: Wrapping<i8>
[src]wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i8>>::MIN, Wrapping(i8::MIN));
pub const MAX: Wrapping<i8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MAX: Wrapping<i8>
[src]wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i8>>::MAX, Wrapping(i8::MAX));
pub const BITS: u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const BITS: u32
[src]wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i8>>::BITS, i8::BITS);
pub const fn count_ones(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_ones(self) -> u32
[src]wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100i8); assert_eq!(n.count_ones(), 3);
pub const fn count_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0i8).count_zeros(), 0);
pub const fn trailing_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn trailing_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000i8); assert_eq!(n.trailing_zeros(), 3);
pub const fn rotate_left(self, n: u32) -> Wrapping<i8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_left(self, n: u32) -> Wrapping<i8>
[src]wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
pub const fn rotate_right(self, n: u32) -> Wrapping<i8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_right(self, n: u32) -> Wrapping<i8>
[src]wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
pub const fn swap_bytes(self) -> Wrapping<i8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn swap_bytes(self) -> Wrapping<i8>
[src]wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
#[must_use]pub const fn reverse_bits(self) -> Wrapping<i8>
1.37.0 (const: 1.37.0)[src]
#[must_use]pub const fn reverse_bits(self) -> Wrapping<i8>
1.37.0 (const: 1.37.0)[src]Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
pub const fn from_be(x: Wrapping<i8>) -> Wrapping<i8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_be(x: Wrapping<i8>) -> Wrapping<i8>
[src]wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai8); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<i8>>::from_be(n), n) } else { assert_eq!(<Wrapping<i8>>::from_be(n), n.swap_bytes()) }
pub const fn from_le(x: Wrapping<i8>) -> Wrapping<i8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_le(x: Wrapping<i8>) -> Wrapping<i8>
[src]wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai8); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<i8>>::from_le(n), n) } else { assert_eq!(<Wrapping<i8>>::from_le(n), n.swap_bytes()) }
pub const fn to_be(self) -> Wrapping<i8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_be(self) -> Wrapping<i8>
[src]wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai8); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
pub const fn to_le(self) -> Wrapping<i8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_le(self) -> Wrapping<i8>
[src]wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai8); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
pub fn pow(self, exp: u32) -> Wrapping<i8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn pow(self, exp: u32) -> Wrapping<i8>
[src]wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
impl Wrapping<i16>
[src]
impl Wrapping<i16>
[src]pub const MIN: Wrapping<i16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MIN: Wrapping<i16>
[src]wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i16>>::MIN, Wrapping(i16::MIN));
pub const MAX: Wrapping<i16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MAX: Wrapping<i16>
[src]wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i16>>::MAX, Wrapping(i16::MAX));
pub const BITS: u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const BITS: u32
[src]wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i16>>::BITS, i16::BITS);
pub const fn count_ones(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_ones(self) -> u32
[src]wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100i16); assert_eq!(n.count_ones(), 3);
pub const fn count_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0i16).count_zeros(), 0);
pub const fn trailing_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn trailing_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000i16); assert_eq!(n.trailing_zeros(), 3);
pub const fn rotate_left(self, n: u32) -> Wrapping<i16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_left(self, n: u32) -> Wrapping<i16>
[src]wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
pub const fn rotate_right(self, n: u32) -> Wrapping<i16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_right(self, n: u32) -> Wrapping<i16>
[src]wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
pub const fn swap_bytes(self) -> Wrapping<i16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn swap_bytes(self) -> Wrapping<i16>
[src]wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
#[must_use]pub const fn reverse_bits(self) -> Wrapping<i16>
1.37.0 (const: 1.37.0)[src]
#[must_use]pub const fn reverse_bits(self) -> Wrapping<i16>
1.37.0 (const: 1.37.0)[src]Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
pub const fn from_be(x: Wrapping<i16>) -> Wrapping<i16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_be(x: Wrapping<i16>) -> Wrapping<i16>
[src]wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai16); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<i16>>::from_be(n), n) } else { assert_eq!(<Wrapping<i16>>::from_be(n), n.swap_bytes()) }
pub const fn from_le(x: Wrapping<i16>) -> Wrapping<i16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_le(x: Wrapping<i16>) -> Wrapping<i16>
[src]wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai16); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<i16>>::from_le(n), n) } else { assert_eq!(<Wrapping<i16>>::from_le(n), n.swap_bytes()) }
pub const fn to_be(self) -> Wrapping<i16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_be(self) -> Wrapping<i16>
[src]wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai16); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
pub const fn to_le(self) -> Wrapping<i16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_le(self) -> Wrapping<i16>
[src]wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai16); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
pub fn pow(self, exp: u32) -> Wrapping<i16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn pow(self, exp: u32) -> Wrapping<i16>
[src]wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i16).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
impl Wrapping<i32>
[src]
impl Wrapping<i32>
[src]pub const MIN: Wrapping<i32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MIN: Wrapping<i32>
[src]wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i32>>::MIN, Wrapping(i32::MIN));
pub const MAX: Wrapping<i32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MAX: Wrapping<i32>
[src]wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i32>>::MAX, Wrapping(i32::MAX));
pub const BITS: u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const BITS: u32
[src]wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i32>>::BITS, i32::BITS);
pub const fn count_ones(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_ones(self) -> u32
[src]wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100i32); assert_eq!(n.count_ones(), 3);
pub const fn count_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0i32).count_zeros(), 0);
pub const fn trailing_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn trailing_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000i32); assert_eq!(n.trailing_zeros(), 3);
pub const fn rotate_left(self, n: u32) -> Wrapping<i32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_left(self, n: u32) -> Wrapping<i32>
[src]wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
pub const fn rotate_right(self, n: u32) -> Wrapping<i32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_right(self, n: u32) -> Wrapping<i32>
[src]wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
pub const fn swap_bytes(self) -> Wrapping<i32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn swap_bytes(self) -> Wrapping<i32>
[src]wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
#[must_use]pub const fn reverse_bits(self) -> Wrapping<i32>
1.37.0 (const: 1.37.0)[src]
#[must_use]pub const fn reverse_bits(self) -> Wrapping<i32>
1.37.0 (const: 1.37.0)[src]Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
pub const fn from_be(x: Wrapping<i32>) -> Wrapping<i32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_be(x: Wrapping<i32>) -> Wrapping<i32>
[src]wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai32); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<i32>>::from_be(n), n) } else { assert_eq!(<Wrapping<i32>>::from_be(n), n.swap_bytes()) }
pub const fn from_le(x: Wrapping<i32>) -> Wrapping<i32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_le(x: Wrapping<i32>) -> Wrapping<i32>
[src]wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai32); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<i32>>::from_le(n), n) } else { assert_eq!(<Wrapping<i32>>::from_le(n), n.swap_bytes()) }
pub const fn to_be(self) -> Wrapping<i32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_be(self) -> Wrapping<i32>
[src]wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai32); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
pub const fn to_le(self) -> Wrapping<i32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_le(self) -> Wrapping<i32>
[src]wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai32); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
pub fn pow(self, exp: u32) -> Wrapping<i32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn pow(self, exp: u32) -> Wrapping<i32>
[src]wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i32).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
impl Wrapping<i64>
[src]
impl Wrapping<i64>
[src]pub const MIN: Wrapping<i64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MIN: Wrapping<i64>
[src]wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i64>>::MIN, Wrapping(i64::MIN));
pub const MAX: Wrapping<i64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MAX: Wrapping<i64>
[src]wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i64>>::MAX, Wrapping(i64::MAX));
pub const BITS: u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const BITS: u32
[src]wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i64>>::BITS, i64::BITS);
pub const fn count_ones(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_ones(self) -> u32
[src]wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100i64); assert_eq!(n.count_ones(), 3);
pub const fn count_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0i64).count_zeros(), 0);
pub const fn trailing_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn trailing_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000i64); assert_eq!(n.trailing_zeros(), 3);
pub const fn rotate_left(self, n: u32) -> Wrapping<i64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_left(self, n: u32) -> Wrapping<i64>
[src]wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
pub const fn rotate_right(self, n: u32) -> Wrapping<i64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_right(self, n: u32) -> Wrapping<i64>
[src]wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
pub const fn swap_bytes(self) -> Wrapping<i64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn swap_bytes(self) -> Wrapping<i64>
[src]wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
#[must_use]pub const fn reverse_bits(self) -> Wrapping<i64>
1.37.0 (const: 1.37.0)[src]
#[must_use]pub const fn reverse_bits(self) -> Wrapping<i64>
1.37.0 (const: 1.37.0)[src]Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
pub const fn from_be(x: Wrapping<i64>) -> Wrapping<i64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_be(x: Wrapping<i64>) -> Wrapping<i64>
[src]wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai64); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<i64>>::from_be(n), n) } else { assert_eq!(<Wrapping<i64>>::from_be(n), n.swap_bytes()) }
pub const fn from_le(x: Wrapping<i64>) -> Wrapping<i64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_le(x: Wrapping<i64>) -> Wrapping<i64>
[src]wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai64); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<i64>>::from_le(n), n) } else { assert_eq!(<Wrapping<i64>>::from_le(n), n.swap_bytes()) }
pub const fn to_be(self) -> Wrapping<i64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_be(self) -> Wrapping<i64>
[src]wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai64); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
pub const fn to_le(self) -> Wrapping<i64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_le(self) -> Wrapping<i64>
[src]wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai64); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
pub fn pow(self, exp: u32) -> Wrapping<i64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn pow(self, exp: u32) -> Wrapping<i64>
[src]wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i64).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
impl Wrapping<i128>
[src]
impl Wrapping<i128>
[src]pub const MIN: Wrapping<i128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MIN: Wrapping<i128>
[src]wrapping_int_impl
)Returns the smallest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i128>>::MIN, Wrapping(i128::MIN));
pub const MAX: Wrapping<i128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const MAX: Wrapping<i128>
[src]wrapping_int_impl
)Returns the largest value that can be represented by this integer type.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i128>>::MAX, Wrapping(i128::MAX));
pub const BITS: u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const BITS: u32
[src]wrapping_int_impl
)Returns the size of this integer type in bits.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(<Wrapping<i128>>::BITS, i128::BITS);
pub const fn count_ones(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_ones(self) -> u32
[src]wrapping_int_impl
)Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b01001100i128); assert_eq!(n.count_ones(), 3);
pub const fn count_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn count_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(!0i128).count_zeros(), 0);
pub const fn trailing_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn trailing_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0b0101000i128); assert_eq!(n.trailing_zeros(), 3);
pub const fn rotate_left(self, n: u32) -> Wrapping<i128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_left(self, n: u32) -> Wrapping<i128>
[src]wrapping_int_impl
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting
integer.
Please note this isn’t the same operation as the <<
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99); assert_eq!(n.rotate_left(32), m);
pub const fn rotate_right(self, n: u32) -> Wrapping<i128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn rotate_right(self, n: u32) -> Wrapping<i128>
[src]wrapping_int_impl
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting
operator!
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF); let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322); assert_eq!(n.rotate_right(4), m);
pub const fn swap_bytes(self) -> Wrapping<i128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn swap_bytes(self) -> Wrapping<i128>
[src]wrapping_int_impl
)Reverses the byte order of the integer.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n: Wrapping<i16> = Wrapping(0b0000000_01010101); assert_eq!(n, Wrapping(85)); let m = n.swap_bytes(); assert_eq!(m, Wrapping(0b01010101_00000000)); assert_eq!(m, Wrapping(21760));
#[must_use]pub const fn reverse_bits(self) -> Wrapping<i128>
1.37.0 (const: 1.37.0)[src]
#[must_use]pub const fn reverse_bits(self) -> Wrapping<i128>
1.37.0 (const: 1.37.0)[src]Reverses the bit pattern of the integer.
Examples
Please note that this example is shared between integer types.
Which explains why i16
is used here.
Basic usage:
use std::num::Wrapping; let n = Wrapping(0b0000000_01010101i16); assert_eq!(n, Wrapping(85)); let m = n.reverse_bits(); assert_eq!(m.0 as u16, 0b10101010_00000000); assert_eq!(m, Wrapping(-22016));
pub const fn from_be(x: Wrapping<i128>) -> Wrapping<i128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_be(x: Wrapping<i128>) -> Wrapping<i128>
[src]wrapping_int_impl
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai128); if cfg!(target_endian = "big") { assert_eq!(<Wrapping<i128>>::from_be(n), n) } else { assert_eq!(<Wrapping<i128>>::from_be(n), n.swap_bytes()) }
pub const fn from_le(x: Wrapping<i128>) -> Wrapping<i128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn from_le(x: Wrapping<i128>) -> Wrapping<i128>
[src]wrapping_int_impl
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai128); if cfg!(target_endian = "little") { assert_eq!(<Wrapping<i128>>::from_le(n), n) } else { assert_eq!(<Wrapping<i128>>::from_le(n), n.swap_bytes()) }
pub const fn to_be(self) -> Wrapping<i128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_be(self) -> Wrapping<i128>
[src]wrapping_int_impl
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai128); if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
pub const fn to_le(self) -> Wrapping<i128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn to_le(self) -> Wrapping<i128>
[src]wrapping_int_impl
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(0x1Ai128); if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }
pub fn pow(self, exp: u32) -> Wrapping<i128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn pow(self, exp: u32) -> Wrapping<i128>
[src]wrapping_int_impl
)Raises self to the power of exp
, using exponentiation by squaring.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i128).pow(4), Wrapping(81));
Results that are too large are wrapped:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13)); assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
impl Wrapping<isize>
[src]
impl Wrapping<isize>
[src]pub const fn leading_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn leading_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(isize::MAX) >> 2; assert_eq!(n.leading_zeros(), 3);
pub fn abs(self) -> Wrapping<isize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn abs(self) -> Wrapping<isize>
[src]wrapping_int_impl
)Computes the absolute value of self
, wrapping around at
the boundary of the type.
The only case where such wrapping can occur is when one takes the absolute value of the negative
minimal value for the type this is a positive value that is too large to represent in the type. In
such a case, this function returns MIN
itself.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(100isize).abs(), Wrapping(100)); assert_eq!(Wrapping(-100isize).abs(), Wrapping(100)); assert_eq!(Wrapping(isize::MIN).abs(), Wrapping(isize::MIN)); assert_eq!(Wrapping(-128i8).abs().0 as u8, 128u8);
pub fn signum(self) -> Wrapping<isize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn signum(self) -> Wrapping<isize>
[src]wrapping_int_impl
)Returns a number representing sign of self
.
0
if the number is zero1
if the number is positive-1
if the number is negative
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(10isize).signum(), Wrapping(1)); assert_eq!(Wrapping(0isize).signum(), Wrapping(0)); assert_eq!(Wrapping(-10isize).signum(), Wrapping(-1));
pub const fn is_positive(self) -> bool
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn is_positive(self) -> bool
[src]wrapping_int_impl
)Returns true
if self
is positive and false
if the number is zero or
negative.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(10isize).is_positive()); assert!(!Wrapping(-10isize).is_positive());
pub const fn is_negative(self) -> bool
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn is_negative(self) -> bool
[src]wrapping_int_impl
)Returns true
if self
is negative and false
if the number is zero or
positive.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(-10isize).is_negative()); assert!(!Wrapping(10isize).is_negative());
impl Wrapping<i8>
[src]
impl Wrapping<i8>
[src]pub const fn leading_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn leading_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(i8::MAX) >> 2; assert_eq!(n.leading_zeros(), 3);
pub fn abs(self) -> Wrapping<i8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn abs(self) -> Wrapping<i8>
[src]wrapping_int_impl
)Computes the absolute value of self
, wrapping around at
the boundary of the type.
The only case where such wrapping can occur is when one takes the absolute value of the negative
minimal value for the type this is a positive value that is too large to represent in the type. In
such a case, this function returns MIN
itself.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(100i8).abs(), Wrapping(100)); assert_eq!(Wrapping(-100i8).abs(), Wrapping(100)); assert_eq!(Wrapping(i8::MIN).abs(), Wrapping(i8::MIN)); assert_eq!(Wrapping(-128i8).abs().0 as u8, 128u8);
pub fn signum(self) -> Wrapping<i8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn signum(self) -> Wrapping<i8>
[src]wrapping_int_impl
)Returns a number representing sign of self
.
0
if the number is zero1
if the number is positive-1
if the number is negative
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(10i8).signum(), Wrapping(1)); assert_eq!(Wrapping(0i8).signum(), Wrapping(0)); assert_eq!(Wrapping(-10i8).signum(), Wrapping(-1));
pub const fn is_positive(self) -> bool
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn is_positive(self) -> bool
[src]wrapping_int_impl
)Returns true
if self
is positive and false
if the number is zero or
negative.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(10i8).is_positive()); assert!(!Wrapping(-10i8).is_positive());
pub const fn is_negative(self) -> bool
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn is_negative(self) -> bool
[src]wrapping_int_impl
)Returns true
if self
is negative and false
if the number is zero or
positive.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(-10i8).is_negative()); assert!(!Wrapping(10i8).is_negative());
impl Wrapping<i16>
[src]
impl Wrapping<i16>
[src]pub const fn leading_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn leading_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(i16::MAX) >> 2; assert_eq!(n.leading_zeros(), 3);
pub fn abs(self) -> Wrapping<i16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn abs(self) -> Wrapping<i16>
[src]wrapping_int_impl
)Computes the absolute value of self
, wrapping around at
the boundary of the type.
The only case where such wrapping can occur is when one takes the absolute value of the negative
minimal value for the type this is a positive value that is too large to represent in the type. In
such a case, this function returns MIN
itself.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(100i16).abs(), Wrapping(100)); assert_eq!(Wrapping(-100i16).abs(), Wrapping(100)); assert_eq!(Wrapping(i16::MIN).abs(), Wrapping(i16::MIN)); assert_eq!(Wrapping(-128i8).abs().0 as u8, 128u8);
pub fn signum(self) -> Wrapping<i16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn signum(self) -> Wrapping<i16>
[src]wrapping_int_impl
)Returns a number representing sign of self
.
0
if the number is zero1
if the number is positive-1
if the number is negative
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(10i16).signum(), Wrapping(1)); assert_eq!(Wrapping(0i16).signum(), Wrapping(0)); assert_eq!(Wrapping(-10i16).signum(), Wrapping(-1));
pub const fn is_positive(self) -> bool
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn is_positive(self) -> bool
[src]wrapping_int_impl
)Returns true
if self
is positive and false
if the number is zero or
negative.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(10i16).is_positive()); assert!(!Wrapping(-10i16).is_positive());
pub const fn is_negative(self) -> bool
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn is_negative(self) -> bool
[src]wrapping_int_impl
)Returns true
if self
is negative and false
if the number is zero or
positive.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(-10i16).is_negative()); assert!(!Wrapping(10i16).is_negative());
impl Wrapping<i32>
[src]
impl Wrapping<i32>
[src]pub const fn leading_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn leading_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(i32::MAX) >> 2; assert_eq!(n.leading_zeros(), 3);
pub fn abs(self) -> Wrapping<i32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn abs(self) -> Wrapping<i32>
[src]wrapping_int_impl
)Computes the absolute value of self
, wrapping around at
the boundary of the type.
The only case where such wrapping can occur is when one takes the absolute value of the negative
minimal value for the type this is a positive value that is too large to represent in the type. In
such a case, this function returns MIN
itself.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(100i32).abs(), Wrapping(100)); assert_eq!(Wrapping(-100i32).abs(), Wrapping(100)); assert_eq!(Wrapping(i32::MIN).abs(), Wrapping(i32::MIN)); assert_eq!(Wrapping(-128i8).abs().0 as u8, 128u8);
pub fn signum(self) -> Wrapping<i32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn signum(self) -> Wrapping<i32>
[src]wrapping_int_impl
)Returns a number representing sign of self
.
0
if the number is zero1
if the number is positive-1
if the number is negative
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(10i32).signum(), Wrapping(1)); assert_eq!(Wrapping(0i32).signum(), Wrapping(0)); assert_eq!(Wrapping(-10i32).signum(), Wrapping(-1));
pub const fn is_positive(self) -> bool
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn is_positive(self) -> bool
[src]wrapping_int_impl
)Returns true
if self
is positive and false
if the number is zero or
negative.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(10i32).is_positive()); assert!(!Wrapping(-10i32).is_positive());
pub const fn is_negative(self) -> bool
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn is_negative(self) -> bool
[src]wrapping_int_impl
)Returns true
if self
is negative and false
if the number is zero or
positive.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(-10i32).is_negative()); assert!(!Wrapping(10i32).is_negative());
impl Wrapping<i64>
[src]
impl Wrapping<i64>
[src]pub const fn leading_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn leading_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(i64::MAX) >> 2; assert_eq!(n.leading_zeros(), 3);
pub fn abs(self) -> Wrapping<i64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn abs(self) -> Wrapping<i64>
[src]wrapping_int_impl
)Computes the absolute value of self
, wrapping around at
the boundary of the type.
The only case where such wrapping can occur is when one takes the absolute value of the negative
minimal value for the type this is a positive value that is too large to represent in the type. In
such a case, this function returns MIN
itself.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(100i64).abs(), Wrapping(100)); assert_eq!(Wrapping(-100i64).abs(), Wrapping(100)); assert_eq!(Wrapping(i64::MIN).abs(), Wrapping(i64::MIN)); assert_eq!(Wrapping(-128i8).abs().0 as u8, 128u8);
pub fn signum(self) -> Wrapping<i64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn signum(self) -> Wrapping<i64>
[src]wrapping_int_impl
)Returns a number representing sign of self
.
0
if the number is zero1
if the number is positive-1
if the number is negative
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(10i64).signum(), Wrapping(1)); assert_eq!(Wrapping(0i64).signum(), Wrapping(0)); assert_eq!(Wrapping(-10i64).signum(), Wrapping(-1));
pub const fn is_positive(self) -> bool
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn is_positive(self) -> bool
[src]wrapping_int_impl
)Returns true
if self
is positive and false
if the number is zero or
negative.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(10i64).is_positive()); assert!(!Wrapping(-10i64).is_positive());
pub const fn is_negative(self) -> bool
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn is_negative(self) -> bool
[src]wrapping_int_impl
)Returns true
if self
is negative and false
if the number is zero or
positive.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(-10i64).is_negative()); assert!(!Wrapping(10i64).is_negative());
impl Wrapping<i128>
[src]
impl Wrapping<i128>
[src]pub const fn leading_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn leading_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(i128::MAX) >> 2; assert_eq!(n.leading_zeros(), 3);
pub fn abs(self) -> Wrapping<i128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn abs(self) -> Wrapping<i128>
[src]wrapping_int_impl
)Computes the absolute value of self
, wrapping around at
the boundary of the type.
The only case where such wrapping can occur is when one takes the absolute value of the negative
minimal value for the type this is a positive value that is too large to represent in the type. In
such a case, this function returns MIN
itself.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(100i128).abs(), Wrapping(100)); assert_eq!(Wrapping(-100i128).abs(), Wrapping(100)); assert_eq!(Wrapping(i128::MIN).abs(), Wrapping(i128::MIN)); assert_eq!(Wrapping(-128i8).abs().0 as u8, 128u8);
pub fn signum(self) -> Wrapping<i128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn signum(self) -> Wrapping<i128>
[src]wrapping_int_impl
)Returns a number representing sign of self
.
0
if the number is zero1
if the number is positive-1
if the number is negative
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert_eq!(Wrapping(10i128).signum(), Wrapping(1)); assert_eq!(Wrapping(0i128).signum(), Wrapping(0)); assert_eq!(Wrapping(-10i128).signum(), Wrapping(-1));
pub const fn is_positive(self) -> bool
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn is_positive(self) -> bool
[src]wrapping_int_impl
)Returns true
if self
is positive and false
if the number is zero or
negative.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(10i128).is_positive()); assert!(!Wrapping(-10i128).is_positive());
pub const fn is_negative(self) -> bool
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn is_negative(self) -> bool
[src]wrapping_int_impl
)Returns true
if self
is negative and false
if the number is zero or
positive.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(-10i128).is_negative()); assert!(!Wrapping(10i128).is_negative());
impl Wrapping<usize>
[src]
impl Wrapping<usize>
[src]pub const fn leading_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn leading_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(usize::MAX) >> 2; assert_eq!(n.leading_zeros(), 2);
pub fn is_power_of_two(self) -> bool
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn is_power_of_two(self) -> bool
[src]wrapping_int_impl
)Returns true
if and only if self == 2^k
for some k
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(16usize).is_power_of_two()); assert!(!Wrapping(10usize).is_power_of_two());
pub fn next_power_of_two(self) -> Wrapping<usize>
[src]
🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
pub fn next_power_of_two(self) -> Wrapping<usize>
[src]🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
Returns the smallest power of two greater than or equal to self
.
When return value overflows (i.e., self > (1 << (N-1))
for type
uN
), overflows to 2^N = 0
.
Examples
Basic usage:
#![feature(wrapping_next_power_of_two)] use std::num::Wrapping; assert_eq!(Wrapping(2usize).next_power_of_two(), Wrapping(2)); assert_eq!(Wrapping(3usize).next_power_of_two(), Wrapping(4)); assert_eq!(Wrapping(200_u8).next_power_of_two(), Wrapping(0));
impl Wrapping<u8>
[src]
impl Wrapping<u8>
[src]pub const fn leading_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn leading_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(u8::MAX) >> 2; assert_eq!(n.leading_zeros(), 2);
pub fn is_power_of_two(self) -> bool
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn is_power_of_two(self) -> bool
[src]wrapping_int_impl
)Returns true
if and only if self == 2^k
for some k
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(16u8).is_power_of_two()); assert!(!Wrapping(10u8).is_power_of_two());
pub fn next_power_of_two(self) -> Wrapping<u8>
[src]
🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
pub fn next_power_of_two(self) -> Wrapping<u8>
[src]🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
Returns the smallest power of two greater than or equal to self
.
When return value overflows (i.e., self > (1 << (N-1))
for type
uN
), overflows to 2^N = 0
.
Examples
Basic usage:
#![feature(wrapping_next_power_of_two)] use std::num::Wrapping; assert_eq!(Wrapping(2u8).next_power_of_two(), Wrapping(2)); assert_eq!(Wrapping(3u8).next_power_of_two(), Wrapping(4)); assert_eq!(Wrapping(200_u8).next_power_of_two(), Wrapping(0));
impl Wrapping<u16>
[src]
impl Wrapping<u16>
[src]pub const fn leading_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn leading_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(u16::MAX) >> 2; assert_eq!(n.leading_zeros(), 2);
pub fn is_power_of_two(self) -> bool
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn is_power_of_two(self) -> bool
[src]wrapping_int_impl
)Returns true
if and only if self == 2^k
for some k
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(16u16).is_power_of_two()); assert!(!Wrapping(10u16).is_power_of_two());
pub fn next_power_of_two(self) -> Wrapping<u16>
[src]
🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
pub fn next_power_of_two(self) -> Wrapping<u16>
[src]🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
Returns the smallest power of two greater than or equal to self
.
When return value overflows (i.e., self > (1 << (N-1))
for type
uN
), overflows to 2^N = 0
.
Examples
Basic usage:
#![feature(wrapping_next_power_of_two)] use std::num::Wrapping; assert_eq!(Wrapping(2u16).next_power_of_two(), Wrapping(2)); assert_eq!(Wrapping(3u16).next_power_of_two(), Wrapping(4)); assert_eq!(Wrapping(200_u8).next_power_of_two(), Wrapping(0));
impl Wrapping<u32>
[src]
impl Wrapping<u32>
[src]pub const fn leading_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn leading_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(u32::MAX) >> 2; assert_eq!(n.leading_zeros(), 2);
pub fn is_power_of_two(self) -> bool
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn is_power_of_two(self) -> bool
[src]wrapping_int_impl
)Returns true
if and only if self == 2^k
for some k
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(16u32).is_power_of_two()); assert!(!Wrapping(10u32).is_power_of_two());
pub fn next_power_of_two(self) -> Wrapping<u32>
[src]
🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
pub fn next_power_of_two(self) -> Wrapping<u32>
[src]🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
Returns the smallest power of two greater than or equal to self
.
When return value overflows (i.e., self > (1 << (N-1))
for type
uN
), overflows to 2^N = 0
.
Examples
Basic usage:
#![feature(wrapping_next_power_of_two)] use std::num::Wrapping; assert_eq!(Wrapping(2u32).next_power_of_two(), Wrapping(2)); assert_eq!(Wrapping(3u32).next_power_of_two(), Wrapping(4)); assert_eq!(Wrapping(200_u8).next_power_of_two(), Wrapping(0));
impl Wrapping<u64>
[src]
impl Wrapping<u64>
[src]pub const fn leading_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn leading_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(u64::MAX) >> 2; assert_eq!(n.leading_zeros(), 2);
pub fn is_power_of_two(self) -> bool
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn is_power_of_two(self) -> bool
[src]wrapping_int_impl
)Returns true
if and only if self == 2^k
for some k
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(16u64).is_power_of_two()); assert!(!Wrapping(10u64).is_power_of_two());
pub fn next_power_of_two(self) -> Wrapping<u64>
[src]
🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
pub fn next_power_of_two(self) -> Wrapping<u64>
[src]🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
Returns the smallest power of two greater than or equal to self
.
When return value overflows (i.e., self > (1 << (N-1))
for type
uN
), overflows to 2^N = 0
.
Examples
Basic usage:
#![feature(wrapping_next_power_of_two)] use std::num::Wrapping; assert_eq!(Wrapping(2u64).next_power_of_two(), Wrapping(2)); assert_eq!(Wrapping(3u64).next_power_of_two(), Wrapping(4)); assert_eq!(Wrapping(200_u8).next_power_of_two(), Wrapping(0));
impl Wrapping<u128>
[src]
impl Wrapping<u128>
[src]pub const fn leading_zeros(self) -> u32
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub const fn leading_zeros(self) -> u32
[src]wrapping_int_impl
)Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; let n = Wrapping(u128::MAX) >> 2; assert_eq!(n.leading_zeros(), 2);
pub fn is_power_of_two(self) -> bool
[src]
🔬 This is a nightly-only experimental API. (wrapping_int_impl
)
pub fn is_power_of_two(self) -> bool
[src]wrapping_int_impl
)Returns true
if and only if self == 2^k
for some k
.
Examples
Basic usage:
#![feature(wrapping_int_impl)] use std::num::Wrapping; assert!(Wrapping(16u128).is_power_of_two()); assert!(!Wrapping(10u128).is_power_of_two());
pub fn next_power_of_two(self) -> Wrapping<u128>
[src]
🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
pub fn next_power_of_two(self) -> Wrapping<u128>
[src]🔬 This is a nightly-only experimental API. (wrapping_next_power_of_two
)
needs decision on wrapping behaviour
Returns the smallest power of two greater than or equal to self
.
When return value overflows (i.e., self > (1 << (N-1))
for type
uN
), overflows to 2^N = 0
.
Examples
Basic usage:
#![feature(wrapping_next_power_of_two)] use std::num::Wrapping; assert_eq!(Wrapping(2u128).next_power_of_two(), Wrapping(2)); assert_eq!(Wrapping(3u128).next_power_of_two(), Wrapping(4)); assert_eq!(Wrapping(200_u8).next_power_of_two(), Wrapping(0));
Trait Implementations
impl<'_> AddAssign<&'_ Wrapping<i128>> for Wrapping<i128>
1.22.0[src]
impl<'_> AddAssign<&'_ Wrapping<i128>> for Wrapping<i128>
1.22.0[src]pub fn add_assign(&mut self, other: &Wrapping<i128>)
[src]
pub fn add_assign(&mut self, other: &Wrapping<i128>)
[src]Performs the +=
operation. Read more
impl<'_> AddAssign<&'_ Wrapping<i16>> for Wrapping<i16>
1.22.0[src]
impl<'_> AddAssign<&'_ Wrapping<i16>> for Wrapping<i16>
1.22.0[src]pub fn add_assign(&mut self, other: &Wrapping<i16>)
[src]
pub fn add_assign(&mut self, other: &Wrapping<i16>)
[src]Performs the +=
operation. Read more
impl<'_> AddAssign<&'_ Wrapping<i32>> for Wrapping<i32>
1.22.0[src]
impl<'_> AddAssign<&'_ Wrapping<i32>> for Wrapping<i32>
1.22.0[src]pub fn add_assign(&mut self, other: &Wrapping<i32>)
[src]
pub fn add_assign(&mut self, other: &Wrapping<i32>)
[src]Performs the +=
operation. Read more
impl<'_> AddAssign<&'_ Wrapping<i64>> for Wrapping<i64>
1.22.0[src]
impl<'_> AddAssign<&'_ Wrapping<i64>> for Wrapping<i64>
1.22.0[src]pub fn add_assign(&mut self, other: &Wrapping<i64>)
[src]
pub fn add_assign(&mut self, other: &Wrapping<i64>)
[src]Performs the +=
operation. Read more
impl<'_> AddAssign<&'_ Wrapping<i8>> for Wrapping<i8>
1.22.0[src]
impl<'_> AddAssign<&'_ Wrapping<i8>> for Wrapping<i8>
1.22.0[src]pub fn add_assign(&mut self, other: &Wrapping<i8>)
[src]
pub fn add_assign(&mut self, other: &Wrapping<i8>)
[src]Performs the +=
operation. Read more
impl<'_> AddAssign<&'_ Wrapping<isize>> for Wrapping<isize>
1.22.0[src]
impl<'_> AddAssign<&'_ Wrapping<isize>> for Wrapping<isize>
1.22.0[src]pub fn add_assign(&mut self, other: &Wrapping<isize>)
[src]
pub fn add_assign(&mut self, other: &Wrapping<isize>)
[src]Performs the +=
operation. Read more
impl<'_> AddAssign<&'_ Wrapping<u128>> for Wrapping<u128>
1.22.0[src]
impl<'_> AddAssign<&'_ Wrapping<u128>> for Wrapping<u128>
1.22.0[src]pub fn add_assign(&mut self, other: &Wrapping<u128>)
[src]
pub fn add_assign(&mut self, other: &Wrapping<u128>)
[src]Performs the +=
operation. Read more
impl<'_> AddAssign<&'_ Wrapping<u16>> for Wrapping<u16>
1.22.0[src]
impl<'_> AddAssign<&'_ Wrapping<u16>> for Wrapping<u16>
1.22.0[src]pub fn add_assign(&mut self, other: &Wrapping<u16>)
[src]
pub fn add_assign(&mut self, other: &Wrapping<u16>)
[src]Performs the +=
operation. Read more
impl<'_> AddAssign<&'_ Wrapping<u32>> for Wrapping<u32>
1.22.0[src]
impl<'_> AddAssign<&'_ Wrapping<u32>> for Wrapping<u32>
1.22.0[src]pub fn add_assign(&mut self, other: &Wrapping<u32>)
[src]
pub fn add_assign(&mut self, other: &Wrapping<u32>)
[src]Performs the +=
operation. Read more
impl<'_> AddAssign<&'_ Wrapping<u64>> for Wrapping<u64>
1.22.0[src]
impl<'_> AddAssign<&'_ Wrapping<u64>> for Wrapping<u64>
1.22.0[src]pub fn add_assign(&mut self, other: &Wrapping<u64>)
[src]
pub fn add_assign(&mut self, other: &Wrapping<u64>)
[src]Performs the +=
operation. Read more
impl<'_> AddAssign<&'_ Wrapping<u8>> for Wrapping<u8>
1.22.0[src]
impl<'_> AddAssign<&'_ Wrapping<u8>> for Wrapping<u8>
1.22.0[src]pub fn add_assign(&mut self, other: &Wrapping<u8>)
[src]
pub fn add_assign(&mut self, other: &Wrapping<u8>)
[src]Performs the +=
operation. Read more
impl<'_> AddAssign<&'_ Wrapping<usize>> for Wrapping<usize>
1.22.0[src]
impl<'_> AddAssign<&'_ Wrapping<usize>> for Wrapping<usize>
1.22.0[src]pub fn add_assign(&mut self, other: &Wrapping<usize>)
[src]
pub fn add_assign(&mut self, other: &Wrapping<usize>)
[src]Performs the +=
operation. Read more
impl AddAssign<Wrapping<i128>> for Wrapping<i128>
1.8.0[src]
impl AddAssign<Wrapping<i128>> for Wrapping<i128>
1.8.0[src]pub fn add_assign(&mut self, other: Wrapping<i128>)
[src]
pub fn add_assign(&mut self, other: Wrapping<i128>)
[src]Performs the +=
operation. Read more
impl AddAssign<Wrapping<i16>> for Wrapping<i16>
1.8.0[src]
impl AddAssign<Wrapping<i16>> for Wrapping<i16>
1.8.0[src]pub fn add_assign(&mut self, other: Wrapping<i16>)
[src]
pub fn add_assign(&mut self, other: Wrapping<i16>)
[src]Performs the +=
operation. Read more
impl AddAssign<Wrapping<i32>> for Wrapping<i32>
1.8.0[src]
impl AddAssign<Wrapping<i32>> for Wrapping<i32>
1.8.0[src]pub fn add_assign(&mut self, other: Wrapping<i32>)
[src]
pub fn add_assign(&mut self, other: Wrapping<i32>)
[src]Performs the +=
operation. Read more
impl AddAssign<Wrapping<i64>> for Wrapping<i64>
1.8.0[src]
impl AddAssign<Wrapping<i64>> for Wrapping<i64>
1.8.0[src]pub fn add_assign(&mut self, other: Wrapping<i64>)
[src]
pub fn add_assign(&mut self, other: Wrapping<i64>)
[src]Performs the +=
operation. Read more
impl AddAssign<Wrapping<i8>> for Wrapping<i8>
1.8.0[src]
impl AddAssign<Wrapping<i8>> for Wrapping<i8>
1.8.0[src]pub fn add_assign(&mut self, other: Wrapping<i8>)
[src]
pub fn add_assign(&mut self, other: Wrapping<i8>)
[src]Performs the +=
operation. Read more
impl AddAssign<Wrapping<isize>> for Wrapping<isize>
1.8.0[src]
impl AddAssign<Wrapping<isize>> for Wrapping<isize>
1.8.0[src]pub fn add_assign(&mut self, other: Wrapping<isize>)
[src]
pub fn add_assign(&mut self, other: Wrapping<isize>)
[src]Performs the +=
operation. Read more
impl AddAssign<Wrapping<u128>> for Wrapping<u128>
1.8.0[src]
impl AddAssign<Wrapping<u128>> for Wrapping<u128>
1.8.0[src]pub fn add_assign(&mut self, other: Wrapping<u128>)
[src]
pub fn add_assign(&mut self, other: Wrapping<u128>)
[src]Performs the +=
operation. Read more
impl AddAssign<Wrapping<u16>> for Wrapping<u16>
1.8.0[src]
impl AddAssign<Wrapping<u16>> for Wrapping<u16>
1.8.0[src]pub fn add_assign(&mut self, other: Wrapping<u16>)
[src]
pub fn add_assign(&mut self, other: Wrapping<u16>)
[src]Performs the +=
operation. Read more
impl AddAssign<Wrapping<u32>> for Wrapping<u32>
1.8.0[src]
impl AddAssign<Wrapping<u32>> for Wrapping<u32>
1.8.0[src]pub fn add_assign(&mut self, other: Wrapping<u32>)
[src]
pub fn add_assign(&mut self, other: Wrapping<u32>)
[src]Performs the +=
operation. Read more
impl AddAssign<Wrapping<u64>> for Wrapping<u64>
1.8.0[src]
impl AddAssign<Wrapping<u64>> for Wrapping<u64>
1.8.0[src]pub fn add_assign(&mut self, other: Wrapping<u64>)
[src]
pub fn add_assign(&mut self, other: Wrapping<u64>)
[src]Performs the +=
operation. Read more
impl AddAssign<Wrapping<u8>> for Wrapping<u8>
1.8.0[src]
impl AddAssign<Wrapping<u8>> for Wrapping<u8>
1.8.0[src]pub fn add_assign(&mut self, other: Wrapping<u8>)
[src]
pub fn add_assign(&mut self, other: Wrapping<u8>)
[src]Performs the +=
operation. Read more
impl AddAssign<Wrapping<usize>> for Wrapping<usize>
1.8.0[src]
impl AddAssign<Wrapping<usize>> for Wrapping<usize>
1.8.0[src]pub fn add_assign(&mut self, other: Wrapping<usize>)
[src]
pub fn add_assign(&mut self, other: Wrapping<usize>)
[src]Performs the +=
operation. Read more
impl<'_> BitAndAssign<&'_ Wrapping<i128>> for Wrapping<i128>
1.22.0[src]
impl<'_> BitAndAssign<&'_ Wrapping<i128>> for Wrapping<i128>
1.22.0[src]pub fn bitand_assign(&mut self, other: &Wrapping<i128>)
[src]
pub fn bitand_assign(&mut self, other: &Wrapping<i128>)
[src]Performs the &=
operation. Read more
impl<'_> BitAndAssign<&'_ Wrapping<i16>> for Wrapping<i16>
1.22.0[src]
impl<'_> BitAndAssign<&'_ Wrapping<i16>> for Wrapping<i16>
1.22.0[src]pub fn bitand_assign(&mut self, other: &Wrapping<i16>)
[src]
pub fn bitand_assign(&mut self, other: &Wrapping<i16>)
[src]Performs the &=
operation. Read more
impl<'_> BitAndAssign<&'_ Wrapping<i32>> for Wrapping<i32>
1.22.0[src]
impl<'_> BitAndAssign<&'_ Wrapping<i32>> for Wrapping<i32>
1.22.0[src]pub fn bitand_assign(&mut self, other: &Wrapping<i32>)
[src]
pub fn bitand_assign(&mut self, other: &Wrapping<i32>)
[src]Performs the &=
operation. Read more
impl<'_> BitAndAssign<&'_ Wrapping<i64>> for Wrapping<i64>
1.22.0[src]
impl<'_> BitAndAssign<&'_ Wrapping<i64>> for Wrapping<i64>
1.22.0[src]pub fn bitand_assign(&mut self, other: &Wrapping<i64>)
[src]
pub fn bitand_assign(&mut self, other: &Wrapping<i64>)
[src]Performs the &=
operation. Read more
impl<'_> BitAndAssign<&'_ Wrapping<i8>> for Wrapping<i8>
1.22.0[src]
impl<'_> BitAndAssign<&'_ Wrapping<i8>> for Wrapping<i8>
1.22.0[src]pub fn bitand_assign(&mut self, other: &Wrapping<i8>)
[src]
pub fn bitand_assign(&mut self, other: &Wrapping<i8>)
[src]Performs the &=
operation. Read more
impl<'_> BitAndAssign<&'_ Wrapping<isize>> for Wrapping<isize>
1.22.0[src]
impl<'_> BitAndAssign<&'_ Wrapping<isize>> for Wrapping<isize>
1.22.0[src]pub fn bitand_assign(&mut self, other: &Wrapping<isize>)
[src]
pub fn bitand_assign(&mut self, other: &Wrapping<isize>)
[src]Performs the &=
operation. Read more
impl<'_> BitAndAssign<&'_ Wrapping<u128>> for Wrapping<u128>
1.22.0[src]
impl<'_> BitAndAssign<&'_ Wrapping<u128>> for Wrapping<u128>
1.22.0[src]pub fn bitand_assign(&mut self, other: &Wrapping<u128>)
[src]
pub fn bitand_assign(&mut self, other: &Wrapping<u128>)
[src]Performs the &=
operation. Read more
impl<'_> BitAndAssign<&'_ Wrapping<u16>> for Wrapping<u16>
1.22.0[src]
impl<'_> BitAndAssign<&'_ Wrapping<u16>> for Wrapping<u16>
1.22.0[src]pub fn bitand_assign(&mut self, other: &Wrapping<u16>)
[src]
pub fn bitand_assign(&mut self, other: &Wrapping<u16>)
[src]Performs the &=
operation. Read more
impl<'_> BitAndAssign<&'_ Wrapping<u32>> for Wrapping<u32>
1.22.0[src]
impl<'_> BitAndAssign<&'_ Wrapping<u32>> for Wrapping<u32>
1.22.0[src]pub fn bitand_assign(&mut self, other: &Wrapping<u32>)
[src]
pub fn bitand_assign(&mut self, other: &Wrapping<u32>)
[src]Performs the &=
operation. Read more
impl<'_> BitAndAssign<&'_ Wrapping<u64>> for Wrapping<u64>
1.22.0[src]
impl<'_> BitAndAssign<&'_ Wrapping<u64>> for Wrapping<u64>
1.22.0[src]pub fn bitand_assign(&mut self, other: &Wrapping<u64>)
[src]
pub fn bitand_assign(&mut self, other: &Wrapping<u64>)
[src]Performs the &=
operation. Read more
impl<'_> BitAndAssign<&'_ Wrapping<u8>> for Wrapping<u8>
1.22.0[src]
impl<'_> BitAndAssign<&'_ Wrapping<u8>> for Wrapping<u8>
1.22.0[src]pub fn bitand_assign(&mut self, other: &Wrapping<u8>)
[src]
pub fn bitand_assign(&mut self, other: &Wrapping<u8>)
[src]Performs the &=
operation. Read more
impl<'_> BitAndAssign<&'_ Wrapping<usize>> for Wrapping<usize>
1.22.0[src]
impl<'_> BitAndAssign<&'_ Wrapping<usize>> for Wrapping<usize>
1.22.0[src]pub fn bitand_assign(&mut self, other: &Wrapping<usize>)
[src]
pub fn bitand_assign(&mut self, other: &Wrapping<usize>)
[src]Performs the &=
operation. Read more
impl BitAndAssign<Wrapping<i128>> for Wrapping<i128>
1.8.0[src]
impl BitAndAssign<Wrapping<i128>> for Wrapping<i128>
1.8.0[src]pub fn bitand_assign(&mut self, other: Wrapping<i128>)
[src]
pub fn bitand_assign(&mut self, other: Wrapping<i128>)
[src]Performs the &=
operation. Read more
impl BitAndAssign<Wrapping<i16>> for Wrapping<i16>
1.8.0[src]
impl BitAndAssign<Wrapping<i16>> for Wrapping<i16>
1.8.0[src]pub fn bitand_assign(&mut self, other: Wrapping<i16>)
[src]
pub fn bitand_assign(&mut self, other: Wrapping<i16>)
[src]Performs the &=
operation. Read more
impl BitAndAssign<Wrapping<i32>> for Wrapping<i32>
1.8.0[src]
impl BitAndAssign<Wrapping<i32>> for Wrapping<i32>
1.8.0[src]pub fn bitand_assign(&mut self, other: Wrapping<i32>)
[src]
pub fn bitand_assign(&mut self, other: Wrapping<i32>)
[src]Performs the &=
operation. Read more
impl BitAndAssign<Wrapping<i64>> for Wrapping<i64>
1.8.0[src]
impl BitAndAssign<Wrapping<i64>> for Wrapping<i64>
1.8.0[src]pub fn bitand_assign(&mut self, other: Wrapping<i64>)
[src]
pub fn bitand_assign(&mut self, other: Wrapping<i64>)
[src]Performs the &=
operation. Read more
impl BitAndAssign<Wrapping<i8>> for Wrapping<i8>
1.8.0[src]
impl BitAndAssign<Wrapping<i8>> for Wrapping<i8>
1.8.0[src]pub fn bitand_assign(&mut self, other: Wrapping<i8>)
[src]
pub fn bitand_assign(&mut self, other: Wrapping<i8>)
[src]Performs the &=
operation. Read more
impl BitAndAssign<Wrapping<isize>> for Wrapping<isize>
1.8.0[src]
impl BitAndAssign<Wrapping<isize>> for Wrapping<isize>
1.8.0[src]pub fn bitand_assign(&mut self, other: Wrapping<isize>)
[src]
pub fn bitand_assign(&mut self, other: Wrapping<isize>)
[src]Performs the &=
operation. Read more
impl BitAndAssign<Wrapping<u128>> for Wrapping<u128>
1.8.0[src]
impl BitAndAssign<Wrapping<u128>> for Wrapping<u128>
1.8.0[src]pub fn bitand_assign(&mut self, other: Wrapping<u128>)
[src]
pub fn bitand_assign(&mut self, other: Wrapping<u128>)
[src]Performs the &=
operation. Read more
impl BitAndAssign<Wrapping<u16>> for Wrapping<u16>
1.8.0[src]
impl BitAndAssign<Wrapping<u16>> for Wrapping<u16>
1.8.0[src]pub fn bitand_assign(&mut self, other: Wrapping<u16>)
[src]
pub fn bitand_assign(&mut self, other: Wrapping<u16>)
[src]Performs the &=
operation. Read more
impl BitAndAssign<Wrapping<u32>> for Wrapping<u32>
1.8.0[src]
impl BitAndAssign<Wrapping<u32>> for Wrapping<u32>
1.8.0[src]pub fn bitand_assign(&mut self, other: Wrapping<u32>)
[src]
pub fn bitand_assign(&mut self, other: Wrapping<u32>)
[src]Performs the &=
operation. Read more
impl BitAndAssign<Wrapping<u64>> for Wrapping<u64>
1.8.0[src]
impl BitAndAssign<Wrapping<u64>> for Wrapping<u64>
1.8.0[src]pub fn bitand_assign(&mut self, other: Wrapping<u64>)
[src]
pub fn bitand_assign(&mut self, other: Wrapping<u64>)
[src]Performs the &=
operation. Read more
impl BitAndAssign<Wrapping<u8>> for Wrapping<u8>
1.8.0[src]
impl BitAndAssign<Wrapping<u8>> for Wrapping<u8>
1.8.0[src]pub fn bitand_assign(&mut self, other: Wrapping<u8>)
[src]
pub fn bitand_assign(&mut self, other: Wrapping<u8>)
[src]Performs the &=
operation. Read more
impl BitAndAssign<Wrapping<usize>> for Wrapping<usize>
1.8.0[src]
impl BitAndAssign<Wrapping<usize>> for Wrapping<usize>
1.8.0[src]pub fn bitand_assign(&mut self, other: Wrapping<usize>)
[src]
pub fn bitand_assign(&mut self, other: Wrapping<usize>)
[src]Performs the &=
operation. Read more
impl<'_> BitOrAssign<&'_ Wrapping<i128>> for Wrapping<i128>
1.22.0[src]
impl<'_> BitOrAssign<&'_ Wrapping<i128>> for Wrapping<i128>
1.22.0[src]pub fn bitor_assign(&mut self, other: &Wrapping<i128>)
[src]
pub fn bitor_assign(&mut self, other: &Wrapping<i128>)
[src]Performs the |=
operation. Read more
impl<'_> BitOrAssign<&'_ Wrapping<i16>> for Wrapping<i16>
1.22.0[src]
impl<'_> BitOrAssign<&'_ Wrapping<i16>> for Wrapping<i16>
1.22.0[src]pub fn bitor_assign(&mut self, other: &Wrapping<i16>)
[src]
pub fn bitor_assign(&mut self, other: &Wrapping<i16>)
[src]Performs the |=
operation. Read more
impl<'_> BitOrAssign<&'_ Wrapping<i32>> for Wrapping<i32>
1.22.0[src]
impl<'_> BitOrAssign<&'_ Wrapping<i32>> for Wrapping<i32>
1.22.0[src]pub fn bitor_assign(&mut self, other: &Wrapping<i32>)
[src]
pub fn bitor_assign(&mut self, other: &Wrapping<i32>)
[src]Performs the |=
operation. Read more
impl<'_> BitOrAssign<&'_ Wrapping<i64>> for Wrapping<i64>
1.22.0[src]
impl<'_> BitOrAssign<&'_ Wrapping<i64>> for Wrapping<i64>
1.22.0[src]pub fn bitor_assign(&mut self, other: &Wrapping<i64>)
[src]
pub fn bitor_assign(&mut self, other: &Wrapping<i64>)
[src]Performs the |=
operation. Read more
impl<'_> BitOrAssign<&'_ Wrapping<i8>> for Wrapping<i8>
1.22.0[src]
impl<'_> BitOrAssign<&'_ Wrapping<i8>> for Wrapping<i8>
1.22.0[src]pub fn bitor_assign(&mut self, other: &Wrapping<i8>)
[src]
pub fn bitor_assign(&mut self, other: &Wrapping<i8>)
[src]Performs the |=
operation. Read more
impl<'_> BitOrAssign<&'_ Wrapping<isize>> for Wrapping<isize>
1.22.0[src]
impl<'_> BitOrAssign<&'_ Wrapping<isize>> for Wrapping<isize>
1.22.0[src]pub fn bitor_assign(&mut self, other: &Wrapping<isize>)
[src]
pub fn bitor_assign(&mut self, other: &Wrapping<isize>)
[src]Performs the |=
operation. Read more
impl<'_> BitOrAssign<&'_ Wrapping<u128>> for Wrapping<u128>
1.22.0[src]
impl<'_> BitOrAssign<&'_ Wrapping<u128>> for Wrapping<u128>
1.22.0[src]pub fn bitor_assign(&mut self, other: &Wrapping<u128>)
[src]
pub fn bitor_assign(&mut self, other: &Wrapping<u128>)
[src]Performs the |=
operation. Read more
impl<'_> BitOrAssign<&'_ Wrapping<u16>> for Wrapping<u16>
1.22.0[src]
impl<'_> BitOrAssign<&'_ Wrapping<u16>> for Wrapping<u16>
1.22.0[src]pub fn bitor_assign(&mut self, other: &Wrapping<u16>)
[src]
pub fn bitor_assign(&mut self, other: &Wrapping<u16>)
[src]Performs the |=
operation. Read more
impl<'_> BitOrAssign<&'_ Wrapping<u32>> for Wrapping<u32>
1.22.0[src]
impl<'_> BitOrAssign<&'_ Wrapping<u32>> for Wrapping<u32>
1.22.0[src]pub fn bitor_assign(&mut self, other: &Wrapping<u32>)
[src]
pub fn bitor_assign(&mut self, other: &Wrapping<u32>)
[src]Performs the |=
operation. Read more
impl<'_> BitOrAssign<&'_ Wrapping<u64>> for Wrapping<u64>
1.22.0[src]
impl<'_> BitOrAssign<&'_ Wrapping<u64>> for Wrapping<u64>
1.22.0[src]pub fn bitor_assign(&mut self, other: &Wrapping<u64>)
[src]
pub fn bitor_assign(&mut self, other: &Wrapping<u64>)
[src]Performs the |=
operation. Read more
impl<'_> BitOrAssign<&'_ Wrapping<u8>> for Wrapping<u8>
1.22.0[src]
impl<'_> BitOrAssign<&'_ Wrapping<u8>> for Wrapping<u8>
1.22.0[src]pub fn bitor_assign(&mut self, other: &Wrapping<u8>)
[src]
pub fn bitor_assign(&mut self, other: &Wrapping<u8>)
[src]Performs the |=
operation. Read more
impl<'_> BitOrAssign<&'_ Wrapping<usize>> for Wrapping<usize>
1.22.0[src]
impl<'_> BitOrAssign<&'_ Wrapping<usize>> for Wrapping<usize>
1.22.0[src]pub fn bitor_assign(&mut self, other: &Wrapping<usize>)
[src]
pub fn bitor_assign(&mut self, other: &Wrapping<usize>)
[src]Performs the |=
operation. Read more
impl BitOrAssign<Wrapping<i128>> for Wrapping<i128>
1.8.0[src]
impl BitOrAssign<Wrapping<i128>> for Wrapping<i128>
1.8.0[src]pub fn bitor_assign(&mut self, other: Wrapping<i128>)
[src]
pub fn bitor_assign(&mut self, other: Wrapping<i128>)
[src]Performs the |=
operation. Read more
impl BitOrAssign<Wrapping<i16>> for Wrapping<i16>
1.8.0[src]
impl BitOrAssign<Wrapping<i16>> for Wrapping<i16>
1.8.0[src]pub fn bitor_assign(&mut self, other: Wrapping<i16>)
[src]
pub fn bitor_assign(&mut self, other: Wrapping<i16>)
[src]Performs the |=
operation. Read more
impl BitOrAssign<Wrapping<i32>> for Wrapping<i32>
1.8.0[src]
impl BitOrAssign<Wrapping<i32>> for Wrapping<i32>
1.8.0[src]pub fn bitor_assign(&mut self, other: Wrapping<i32>)
[src]
pub fn bitor_assign(&mut self, other: Wrapping<i32>)
[src]Performs the |=
operation. Read more
impl BitOrAssign<Wrapping<i64>> for Wrapping<i64>
1.8.0[src]
impl BitOrAssign<Wrapping<i64>> for Wrapping<i64>
1.8.0[src]pub fn bitor_assign(&mut self, other: Wrapping<i64>)
[src]
pub fn bitor_assign(&mut self, other: Wrapping<i64>)
[src]Performs the |=
operation. Read more
impl BitOrAssign<Wrapping<i8>> for Wrapping<i8>
1.8.0[src]
impl BitOrAssign<Wrapping<i8>> for Wrapping<i8>
1.8.0[src]pub fn bitor_assign(&mut self, other: Wrapping<i8>)
[src]
pub fn bitor_assign(&mut self, other: Wrapping<i8>)
[src]Performs the |=
operation. Read more
impl BitOrAssign<Wrapping<isize>> for Wrapping<isize>
1.8.0[src]
impl BitOrAssign<Wrapping<isize>> for Wrapping<isize>
1.8.0[src]pub fn bitor_assign(&mut self, other: Wrapping<isize>)
[src]
pub fn bitor_assign(&mut self, other: Wrapping<isize>)
[src]Performs the |=
operation. Read more
impl BitOrAssign<Wrapping<u128>> for Wrapping<u128>
1.8.0[src]
impl BitOrAssign<Wrapping<u128>> for Wrapping<u128>
1.8.0[src]pub fn bitor_assign(&mut self, other: Wrapping<u128>)
[src]
pub fn bitor_assign(&mut self, other: Wrapping<u128>)
[src]Performs the |=
operation. Read more
impl BitOrAssign<Wrapping<u16>> for Wrapping<u16>
1.8.0[src]
impl BitOrAssign<Wrapping<u16>> for Wrapping<u16>
1.8.0[src]pub fn bitor_assign(&mut self, other: Wrapping<u16>)
[src]
pub fn bitor_assign(&mut self, other: Wrapping<u16>)
[src]Performs the |=
operation. Read more
impl BitOrAssign<Wrapping<u32>> for Wrapping<u32>
1.8.0[src]
impl BitOrAssign<Wrapping<u32>> for Wrapping<u32>
1.8.0[src]pub fn bitor_assign(&mut self, other: Wrapping<u32>)
[src]
pub fn bitor_assign(&mut self, other: Wrapping<u32>)
[src]Performs the |=
operation. Read more
impl BitOrAssign<Wrapping<u64>> for Wrapping<u64>
1.8.0[src]
impl BitOrAssign<Wrapping<u64>> for Wrapping<u64>
1.8.0[src]pub fn bitor_assign(&mut self, other: Wrapping<u64>)
[src]
pub fn bitor_assign(&mut self, other: Wrapping<u64>)
[src]Performs the |=
operation. Read more
impl BitOrAssign<Wrapping<u8>> for Wrapping<u8>
1.8.0[src]
impl BitOrAssign<Wrapping<u8>> for Wrapping<u8>
1.8.0[src]pub fn bitor_assign(&mut self, other: Wrapping<u8>)
[src]
pub fn bitor_assign(&mut self, other: Wrapping<u8>)
[src]Performs the |=
operation. Read more
impl BitOrAssign<Wrapping<usize>> for Wrapping<usize>
1.8.0[src]
impl BitOrAssign<Wrapping<usize>> for Wrapping<usize>
1.8.0[src]pub fn bitor_assign(&mut self, other: Wrapping<usize>)
[src]
pub fn bitor_assign(&mut self, other: Wrapping<usize>)
[src]Performs the |=
operation. Read more
impl<'_> BitXorAssign<&'_ Wrapping<i128>> for Wrapping<i128>
1.22.0[src]
impl<'_> BitXorAssign<&'_ Wrapping<i128>> for Wrapping<i128>
1.22.0[src]pub fn bitxor_assign(&mut self, other: &Wrapping<i128>)
[src]
pub fn bitxor_assign(&mut self, other: &Wrapping<i128>)
[src]Performs the ^=
operation. Read more
impl<'_> BitXorAssign<&'_ Wrapping<i16>> for Wrapping<i16>
1.22.0[src]
impl<'_> BitXorAssign<&'_ Wrapping<i16>> for Wrapping<i16>
1.22.0[src]pub fn bitxor_assign(&mut self, other: &Wrapping<i16>)
[src]
pub fn bitxor_assign(&mut self, other: &Wrapping<i16>)
[src]Performs the ^=
operation. Read more
impl<'_> BitXorAssign<&'_ Wrapping<i32>> for Wrapping<i32>
1.22.0[src]
impl<'_> BitXorAssign<&'_ Wrapping<i32>> for Wrapping<i32>
1.22.0[src]pub fn bitxor_assign(&mut self, other: &Wrapping<i32>)
[src]
pub fn bitxor_assign(&mut self, other: &Wrapping<i32>)
[src]Performs the ^=
operation. Read more
impl<'_> BitXorAssign<&'_ Wrapping<i64>> for Wrapping<i64>
1.22.0[src]
impl<'_> BitXorAssign<&'_ Wrapping<i64>> for Wrapping<i64>
1.22.0[src]pub fn bitxor_assign(&mut self, other: &Wrapping<i64>)
[src]
pub fn bitxor_assign(&mut self, other: &Wrapping<i64>)
[src]Performs the ^=
operation. Read more
impl<'_> BitXorAssign<&'_ Wrapping<i8>> for Wrapping<i8>
1.22.0[src]
impl<'_> BitXorAssign<&'_ Wrapping<i8>> for Wrapping<i8>
1.22.0[src]pub fn bitxor_assign(&mut self, other: &Wrapping<i8>)
[src]
pub fn bitxor_assign(&mut self, other: &Wrapping<i8>)
[src]Performs the ^=
operation. Read more
impl<'_> BitXorAssign<&'_ Wrapping<isize>> for Wrapping<isize>
1.22.0[src]
impl<'_> BitXorAssign<&'_ Wrapping<isize>> for Wrapping<isize>
1.22.0[src]pub fn bitxor_assign(&mut self, other: &Wrapping<isize>)
[src]
pub fn bitxor_assign(&mut self, other: &Wrapping<isize>)
[src]Performs the ^=
operation. Read more
impl<'_> BitXorAssign<&'_ Wrapping<u128>> for Wrapping<u128>
1.22.0[src]
impl<'_> BitXorAssign<&'_ Wrapping<u128>> for Wrapping<u128>
1.22.0[src]pub fn bitxor_assign(&mut self, other: &Wrapping<u128>)
[src]
pub fn bitxor_assign(&mut self, other: &Wrapping<u128>)
[src]Performs the ^=
operation. Read more
impl<'_> BitXorAssign<&'_ Wrapping<u16>> for Wrapping<u16>
1.22.0[src]
impl<'_> BitXorAssign<&'_ Wrapping<u16>> for Wrapping<u16>
1.22.0[src]pub fn bitxor_assign(&mut self, other: &Wrapping<u16>)
[src]
pub fn bitxor_assign(&mut self, other: &Wrapping<u16>)
[src]Performs the ^=
operation. Read more
impl<'_> BitXorAssign<&'_ Wrapping<u32>> for Wrapping<u32>
1.22.0[src]
impl<'_> BitXorAssign<&'_ Wrapping<u32>> for Wrapping<u32>
1.22.0[src]pub fn bitxor_assign(&mut self, other: &Wrapping<u32>)
[src]
pub fn bitxor_assign(&mut self, other: &Wrapping<u32>)
[src]Performs the ^=
operation. Read more
impl<'_> BitXorAssign<&'_ Wrapping<u64>> for Wrapping<u64>
1.22.0[src]
impl<'_> BitXorAssign<&'_ Wrapping<u64>> for Wrapping<u64>
1.22.0[src]pub fn bitxor_assign(&mut self, other: &Wrapping<u64>)
[src]
pub fn bitxor_assign(&mut self, other: &Wrapping<u64>)
[src]Performs the ^=
operation. Read more
impl<'_> BitXorAssign<&'_ Wrapping<u8>> for Wrapping<u8>
1.22.0[src]
impl<'_> BitXorAssign<&'_ Wrapping<u8>> for Wrapping<u8>
1.22.0[src]pub fn bitxor_assign(&mut self, other: &Wrapping<u8>)
[src]
pub fn bitxor_assign(&mut self, other: &Wrapping<u8>)
[src]Performs the ^=
operation. Read more
impl<'_> BitXorAssign<&'_ Wrapping<usize>> for Wrapping<usize>
1.22.0[src]
impl<'_> BitXorAssign<&'_ Wrapping<usize>> for Wrapping<usize>
1.22.0[src]pub fn bitxor_assign(&mut self, other: &Wrapping<usize>)
[src]
pub fn bitxor_assign(&mut self, other: &Wrapping<usize>)
[src]Performs the ^=
operation. Read more
impl BitXorAssign<Wrapping<i128>> for Wrapping<i128>
1.8.0[src]
impl BitXorAssign<Wrapping<i128>> for Wrapping<i128>
1.8.0[src]pub fn bitxor_assign(&mut self, other: Wrapping<i128>)
[src]
pub fn bitxor_assign(&mut self, other: Wrapping<i128>)
[src]Performs the ^=
operation. Read more
impl BitXorAssign<Wrapping<i16>> for Wrapping<i16>
1.8.0[src]
impl BitXorAssign<Wrapping<i16>> for Wrapping<i16>
1.8.0[src]pub fn bitxor_assign(&mut self, other: Wrapping<i16>)
[src]
pub fn bitxor_assign(&mut self, other: Wrapping<i16>)
[src]Performs the ^=
operation. Read more
impl BitXorAssign<Wrapping<i32>> for Wrapping<i32>
1.8.0[src]
impl BitXorAssign<Wrapping<i32>> for Wrapping<i32>
1.8.0[src]pub fn bitxor_assign(&mut self, other: Wrapping<i32>)
[src]
pub fn bitxor_assign(&mut self, other: Wrapping<i32>)
[src]Performs the ^=
operation. Read more
impl BitXorAssign<Wrapping<i64>> for Wrapping<i64>
1.8.0[src]
impl BitXorAssign<Wrapping<i64>> for Wrapping<i64>
1.8.0[src]pub fn bitxor_assign(&mut self, other: Wrapping<i64>)
[src]
pub fn bitxor_assign(&mut self, other: Wrapping<i64>)
[src]Performs the ^=
operation. Read more
impl BitXorAssign<Wrapping<i8>> for Wrapping<i8>
1.8.0[src]
impl BitXorAssign<Wrapping<i8>> for Wrapping<i8>
1.8.0[src]pub fn bitxor_assign(&mut self, other: Wrapping<i8>)
[src]
pub fn bitxor_assign(&mut self, other: Wrapping<i8>)
[src]Performs the ^=
operation. Read more
impl BitXorAssign<Wrapping<isize>> for Wrapping<isize>
1.8.0[src]
impl BitXorAssign<Wrapping<isize>> for Wrapping<isize>
1.8.0[src]pub fn bitxor_assign(&mut self, other: Wrapping<isize>)
[src]
pub fn bitxor_assign(&mut self, other: Wrapping<isize>)
[src]Performs the ^=
operation. Read more
impl BitXorAssign<Wrapping<u128>> for Wrapping<u128>
1.8.0[src]
impl BitXorAssign<Wrapping<u128>> for Wrapping<u128>
1.8.0[src]pub fn bitxor_assign(&mut self, other: Wrapping<u128>)
[src]
pub fn bitxor_assign(&mut self, other: Wrapping<u128>)
[src]Performs the ^=
operation. Read more
impl BitXorAssign<Wrapping<u16>> for Wrapping<u16>
1.8.0[src]
impl BitXorAssign<Wrapping<u16>> for Wrapping<u16>
1.8.0[src]pub fn bitxor_assign(&mut self, other: Wrapping<u16>)
[src]
pub fn bitxor_assign(&mut self, other: Wrapping<u16>)
[src]Performs the ^=
operation. Read more
impl BitXorAssign<Wrapping<u32>> for Wrapping<u32>
1.8.0[src]
impl BitXorAssign<Wrapping<u32>> for Wrapping<u32>
1.8.0[src]pub fn bitxor_assign(&mut self, other: Wrapping<u32>)
[src]
pub fn bitxor_assign(&mut self, other: Wrapping<u32>)
[src]Performs the ^=
operation. Read more
impl BitXorAssign<Wrapping<u64>> for Wrapping<u64>
1.8.0[src]
impl BitXorAssign<Wrapping<u64>> for Wrapping<u64>
1.8.0[src]pub fn bitxor_assign(&mut self, other: Wrapping<u64>)
[src]
pub fn bitxor_assign(&mut self, other: Wrapping<u64>)
[src]Performs the ^=
operation. Read more
impl BitXorAssign<Wrapping<u8>> for Wrapping<u8>
1.8.0[src]
impl BitXorAssign<Wrapping<u8>> for Wrapping<u8>
1.8.0[src]pub fn bitxor_assign(&mut self, other: Wrapping<u8>)
[src]
pub fn bitxor_assign(&mut self, other: Wrapping<u8>)
[src]Performs the ^=
operation. Read more
impl BitXorAssign<Wrapping<usize>> for Wrapping<usize>
1.8.0[src]
impl BitXorAssign<Wrapping<usize>> for Wrapping<usize>
1.8.0[src]pub fn bitxor_assign(&mut self, other: Wrapping<usize>)
[src]
pub fn bitxor_assign(&mut self, other: Wrapping<usize>)
[src]Performs the ^=
operation. Read more
impl<'de, T> Deserialize<'de> for Wrapping<T> where
T: Deserialize<'de>,
[src]
impl<'de, T> Deserialize<'de> for Wrapping<T> where
T: Deserialize<'de>,
[src]pub fn deserialize<D>(
deserializer: D
) -> Result<Wrapping<T>, <D as Deserializer<'de>>::Error> where
D: Deserializer<'de>,
[src]
pub fn deserialize<D>(
deserializer: D
) -> Result<Wrapping<T>, <D as Deserializer<'de>>::Error> where
D: Deserializer<'de>,
[src]Deserialize this value from the given Serde deserializer. Read more
impl<'_> DivAssign<&'_ Wrapping<i128>> for Wrapping<i128>
1.22.0[src]
impl<'_> DivAssign<&'_ Wrapping<i128>> for Wrapping<i128>
1.22.0[src]pub fn div_assign(&mut self, other: &Wrapping<i128>)
[src]
pub fn div_assign(&mut self, other: &Wrapping<i128>)
[src]Performs the /=
operation. Read more
impl<'_> DivAssign<&'_ Wrapping<i16>> for Wrapping<i16>
1.22.0[src]
impl<'_> DivAssign<&'_ Wrapping<i16>> for Wrapping<i16>
1.22.0[src]pub fn div_assign(&mut self, other: &Wrapping<i16>)
[src]
pub fn div_assign(&mut self, other: &Wrapping<i16>)
[src]Performs the /=
operation. Read more
impl<'_> DivAssign<&'_ Wrapping<i32>> for Wrapping<i32>
1.22.0[src]
impl<'_> DivAssign<&'_ Wrapping<i32>> for Wrapping<i32>
1.22.0[src]pub fn div_assign(&mut self, other: &Wrapping<i32>)
[src]
pub fn div_assign(&mut self, other: &Wrapping<i32>)
[src]Performs the /=
operation. Read more
impl<'_> DivAssign<&'_ Wrapping<i64>> for Wrapping<i64>
1.22.0[src]
impl<'_> DivAssign<&'_ Wrapping<i64>> for Wrapping<i64>
1.22.0[src]pub fn div_assign(&mut self, other: &Wrapping<i64>)
[src]
pub fn div_assign(&mut self, other: &Wrapping<i64>)
[src]Performs the /=
operation. Read more
impl<'_> DivAssign<&'_ Wrapping<i8>> for Wrapping<i8>
1.22.0[src]
impl<'_> DivAssign<&'_ Wrapping<i8>> for Wrapping<i8>
1.22.0[src]pub fn div_assign(&mut self, other: &Wrapping<i8>)
[src]
pub fn div_assign(&mut self, other: &Wrapping<i8>)
[src]Performs the /=
operation. Read more
impl<'_> DivAssign<&'_ Wrapping<isize>> for Wrapping<isize>
1.22.0[src]
impl<'_> DivAssign<&'_ Wrapping<isize>> for Wrapping<isize>
1.22.0[src]pub fn div_assign(&mut self, other: &Wrapping<isize>)
[src]
pub fn div_assign(&mut self, other: &Wrapping<isize>)
[src]Performs the /=
operation. Read more
impl<'_> DivAssign<&'_ Wrapping<u128>> for Wrapping<u128>
1.22.0[src]
impl<'_> DivAssign<&'_ Wrapping<u128>> for Wrapping<u128>
1.22.0[src]pub fn div_assign(&mut self, other: &Wrapping<u128>)
[src]
pub fn div_assign(&mut self, other: &Wrapping<u128>)
[src]Performs the /=
operation. Read more
impl<'_> DivAssign<&'_ Wrapping<u16>> for Wrapping<u16>
1.22.0[src]
impl<'_> DivAssign<&'_ Wrapping<u16>> for Wrapping<u16>
1.22.0[src]pub fn div_assign(&mut self, other: &Wrapping<u16>)
[src]
pub fn div_assign(&mut self, other: &Wrapping<u16>)
[src]Performs the /=
operation. Read more
impl<'_> DivAssign<&'_ Wrapping<u32>> for Wrapping<u32>
1.22.0[src]
impl<'_> DivAssign<&'_ Wrapping<u32>> for Wrapping<u32>
1.22.0[src]pub fn div_assign(&mut self, other: &Wrapping<u32>)
[src]
pub fn div_assign(&mut self, other: &Wrapping<u32>)
[src]Performs the /=
operation. Read more
impl<'_> DivAssign<&'_ Wrapping<u64>> for Wrapping<u64>
1.22.0[src]
impl<'_> DivAssign<&'_ Wrapping<u64>> for Wrapping<u64>
1.22.0[src]pub fn div_assign(&mut self, other: &Wrapping<u64>)
[src]
pub fn div_assign(&mut self, other: &Wrapping<u64>)
[src]Performs the /=
operation. Read more
impl<'_> DivAssign<&'_ Wrapping<u8>> for Wrapping<u8>
1.22.0[src]
impl<'_> DivAssign<&'_ Wrapping<u8>> for Wrapping<u8>
1.22.0[src]pub fn div_assign(&mut self, other: &Wrapping<u8>)
[src]
pub fn div_assign(&mut self, other: &Wrapping<u8>)
[src]Performs the /=
operation. Read more
impl<'_> DivAssign<&'_ Wrapping<usize>> for Wrapping<usize>
1.22.0[src]
impl<'_> DivAssign<&'_ Wrapping<usize>> for Wrapping<usize>
1.22.0[src]pub fn div_assign(&mut self, other: &Wrapping<usize>)
[src]
pub fn div_assign(&mut self, other: &Wrapping<usize>)
[src]Performs the /=
operation. Read more
impl DivAssign<Wrapping<i128>> for Wrapping<i128>
1.8.0[src]
impl DivAssign<Wrapping<i128>> for Wrapping<i128>
1.8.0[src]pub fn div_assign(&mut self, other: Wrapping<i128>)
[src]
pub fn div_assign(&mut self, other: Wrapping<i128>)
[src]Performs the /=
operation. Read more
impl DivAssign<Wrapping<i16>> for Wrapping<i16>
1.8.0[src]
impl DivAssign<Wrapping<i16>> for Wrapping<i16>
1.8.0[src]pub fn div_assign(&mut self, other: Wrapping<i16>)
[src]
pub fn div_assign(&mut self, other: Wrapping<i16>)
[src]Performs the /=
operation. Read more
impl DivAssign<Wrapping<i32>> for Wrapping<i32>
1.8.0[src]
impl DivAssign<Wrapping<i32>> for Wrapping<i32>
1.8.0[src]pub fn div_assign(&mut self, other: Wrapping<i32>)
[src]
pub fn div_assign(&mut self, other: Wrapping<i32>)
[src]Performs the /=
operation. Read more
impl DivAssign<Wrapping<i64>> for Wrapping<i64>
1.8.0[src]
impl DivAssign<Wrapping<i64>> for Wrapping<i64>
1.8.0[src]pub fn div_assign(&mut self, other: Wrapping<i64>)
[src]
pub fn div_assign(&mut self, other: Wrapping<i64>)
[src]Performs the /=
operation. Read more
impl DivAssign<Wrapping<i8>> for Wrapping<i8>
1.8.0[src]
impl DivAssign<Wrapping<i8>> for Wrapping<i8>
1.8.0[src]pub fn div_assign(&mut self, other: Wrapping<i8>)
[src]
pub fn div_assign(&mut self, other: Wrapping<i8>)
[src]Performs the /=
operation. Read more
impl DivAssign<Wrapping<isize>> for Wrapping<isize>
1.8.0[src]
impl DivAssign<Wrapping<isize>> for Wrapping<isize>
1.8.0[src]pub fn div_assign(&mut self, other: Wrapping<isize>)
[src]
pub fn div_assign(&mut self, other: Wrapping<isize>)
[src]Performs the /=
operation. Read more
impl DivAssign<Wrapping<u128>> for Wrapping<u128>
1.8.0[src]
impl DivAssign<Wrapping<u128>> for Wrapping<u128>
1.8.0[src]pub fn div_assign(&mut self, other: Wrapping<u128>)
[src]
pub fn div_assign(&mut self, other: Wrapping<u128>)
[src]Performs the /=
operation. Read more
impl DivAssign<Wrapping<u16>> for Wrapping<u16>
1.8.0[src]
impl DivAssign<Wrapping<u16>> for Wrapping<u16>
1.8.0[src]pub fn div_assign(&mut self, other: Wrapping<u16>)
[src]
pub fn div_assign(&mut self, other: Wrapping<u16>)
[src]Performs the /=
operation. Read more
impl DivAssign<Wrapping<u32>> for Wrapping<u32>
1.8.0[src]
impl DivAssign<Wrapping<u32>> for Wrapping<u32>
1.8.0[src]pub fn div_assign(&mut self, other: Wrapping<u32>)
[src]
pub fn div_assign(&mut self, other: Wrapping<u32>)
[src]Performs the /=
operation. Read more
impl DivAssign<Wrapping<u64>> for Wrapping<u64>
1.8.0[src]
impl DivAssign<Wrapping<u64>> for Wrapping<u64>
1.8.0[src]pub fn div_assign(&mut self, other: Wrapping<u64>)
[src]
pub fn div_assign(&mut self, other: Wrapping<u64>)
[src]Performs the /=
operation. Read more
impl DivAssign<Wrapping<u8>> for Wrapping<u8>
1.8.0[src]
impl DivAssign<Wrapping<u8>> for Wrapping<u8>
1.8.0[src]pub fn div_assign(&mut self, other: Wrapping<u8>)
[src]
pub fn div_assign(&mut self, other: Wrapping<u8>)
[src]Performs the /=
operation. Read more
impl DivAssign<Wrapping<usize>> for Wrapping<usize>
1.8.0[src]
impl DivAssign<Wrapping<usize>> for Wrapping<usize>
1.8.0[src]pub fn div_assign(&mut self, other: Wrapping<usize>)
[src]
pub fn div_assign(&mut self, other: Wrapping<usize>)
[src]Performs the /=
operation. Read more
impl<T> FromPrimitive for Wrapping<T> where
T: FromPrimitive,
[src]
impl<T> FromPrimitive for Wrapping<T> where
T: FromPrimitive,
[src]pub fn from_isize(n: isize) -> Option<Wrapping<T>>
[src]
pub fn from_isize(n: isize) -> Option<Wrapping<T>>
[src]Converts an isize
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
pub fn from_i8(n: i8) -> Option<Wrapping<T>>
[src]
pub fn from_i8(n: i8) -> Option<Wrapping<T>>
[src]Converts an i8
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
pub fn from_i16(n: i16) -> Option<Wrapping<T>>
[src]
pub fn from_i16(n: i16) -> Option<Wrapping<T>>
[src]Converts an i16
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
pub fn from_i32(n: i32) -> Option<Wrapping<T>>
[src]
pub fn from_i32(n: i32) -> Option<Wrapping<T>>
[src]Converts an i32
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
pub fn from_i64(n: i64) -> Option<Wrapping<T>>
[src]
pub fn from_i64(n: i64) -> Option<Wrapping<T>>
[src]Converts an i64
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
pub fn from_i128(n: i128) -> Option<Wrapping<T>>
[src]
pub fn from_i128(n: i128) -> Option<Wrapping<T>>
[src]Converts an i128
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
pub fn from_usize(n: usize) -> Option<Wrapping<T>>
[src]
pub fn from_usize(n: usize) -> Option<Wrapping<T>>
[src]Converts a usize
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
pub fn from_u8(n: u8) -> Option<Wrapping<T>>
[src]
pub fn from_u8(n: u8) -> Option<Wrapping<T>>
[src]Converts an u8
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
pub fn from_u16(n: u16) -> Option<Wrapping<T>>
[src]
pub fn from_u16(n: u16) -> Option<Wrapping<T>>
[src]Converts an u16
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
pub fn from_u32(n: u32) -> Option<Wrapping<T>>
[src]
pub fn from_u32(n: u32) -> Option<Wrapping<T>>
[src]Converts an u32
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
pub fn from_u64(n: u64) -> Option<Wrapping<T>>
[src]
pub fn from_u64(n: u64) -> Option<Wrapping<T>>
[src]Converts an u64
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
pub fn from_u128(n: u128) -> Option<Wrapping<T>>
[src]
pub fn from_u128(n: u128) -> Option<Wrapping<T>>
[src]Converts an u128
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
impl<'_> MulAssign<&'_ Wrapping<i128>> for Wrapping<i128>
1.22.0[src]
impl<'_> MulAssign<&'_ Wrapping<i128>> for Wrapping<i128>
1.22.0[src]pub fn mul_assign(&mut self, other: &Wrapping<i128>)
[src]
pub fn mul_assign(&mut self, other: &Wrapping<i128>)
[src]Performs the *=
operation. Read more
impl<'_> MulAssign<&'_ Wrapping<i16>> for Wrapping<i16>
1.22.0[src]
impl<'_> MulAssign<&'_ Wrapping<i16>> for Wrapping<i16>
1.22.0[src]pub fn mul_assign(&mut self, other: &Wrapping<i16>)
[src]
pub fn mul_assign(&mut self, other: &Wrapping<i16>)
[src]Performs the *=
operation. Read more
impl<'_> MulAssign<&'_ Wrapping<i32>> for Wrapping<i32>
1.22.0[src]
impl<'_> MulAssign<&'_ Wrapping<i32>> for Wrapping<i32>
1.22.0[src]pub fn mul_assign(&mut self, other: &Wrapping<i32>)
[src]
pub fn mul_assign(&mut self, other: &Wrapping<i32>)
[src]Performs the *=
operation. Read more
impl<'_> MulAssign<&'_ Wrapping<i64>> for Wrapping<i64>
1.22.0[src]
impl<'_> MulAssign<&'_ Wrapping<i64>> for Wrapping<i64>
1.22.0[src]pub fn mul_assign(&mut self, other: &Wrapping<i64>)
[src]
pub fn mul_assign(&mut self, other: &Wrapping<i64>)
[src]Performs the *=
operation. Read more
impl<'_> MulAssign<&'_ Wrapping<i8>> for Wrapping<i8>
1.22.0[src]
impl<'_> MulAssign<&'_ Wrapping<i8>> for Wrapping<i8>
1.22.0[src]pub fn mul_assign(&mut self, other: &Wrapping<i8>)
[src]
pub fn mul_assign(&mut self, other: &Wrapping<i8>)
[src]Performs the *=
operation. Read more
impl<'_> MulAssign<&'_ Wrapping<isize>> for Wrapping<isize>
1.22.0[src]
impl<'_> MulAssign<&'_ Wrapping<isize>> for Wrapping<isize>
1.22.0[src]pub fn mul_assign(&mut self, other: &Wrapping<isize>)
[src]
pub fn mul_assign(&mut self, other: &Wrapping<isize>)
[src]Performs the *=
operation. Read more
impl<'_> MulAssign<&'_ Wrapping<u128>> for Wrapping<u128>
1.22.0[src]
impl<'_> MulAssign<&'_ Wrapping<u128>> for Wrapping<u128>
1.22.0[src]pub fn mul_assign(&mut self, other: &Wrapping<u128>)
[src]
pub fn mul_assign(&mut self, other: &Wrapping<u128>)
[src]Performs the *=
operation. Read more
impl<'_> MulAssign<&'_ Wrapping<u16>> for Wrapping<u16>
1.22.0[src]
impl<'_> MulAssign<&'_ Wrapping<u16>> for Wrapping<u16>
1.22.0[src]pub fn mul_assign(&mut self, other: &Wrapping<u16>)
[src]
pub fn mul_assign(&mut self, other: &Wrapping<u16>)
[src]Performs the *=
operation. Read more
impl<'_> MulAssign<&'_ Wrapping<u32>> for Wrapping<u32>
1.22.0[src]
impl<'_> MulAssign<&'_ Wrapping<u32>> for Wrapping<u32>
1.22.0[src]pub fn mul_assign(&mut self, other: &Wrapping<u32>)
[src]
pub fn mul_assign(&mut self, other: &Wrapping<u32>)
[src]Performs the *=
operation. Read more
impl<'_> MulAssign<&'_ Wrapping<u64>> for Wrapping<u64>
1.22.0[src]
impl<'_> MulAssign<&'_ Wrapping<u64>> for Wrapping<u64>
1.22.0[src]pub fn mul_assign(&mut self, other: &Wrapping<u64>)
[src]
pub fn mul_assign(&mut self, other: &Wrapping<u64>)
[src]Performs the *=
operation. Read more
impl<'_> MulAssign<&'_ Wrapping<u8>> for Wrapping<u8>
1.22.0[src]
impl<'_> MulAssign<&'_ Wrapping<u8>> for Wrapping<u8>
1.22.0[src]pub fn mul_assign(&mut self, other: &Wrapping<u8>)
[src]
pub fn mul_assign(&mut self, other: &Wrapping<u8>)
[src]Performs the *=
operation. Read more
impl<'_> MulAssign<&'_ Wrapping<usize>> for Wrapping<usize>
1.22.0[src]
impl<'_> MulAssign<&'_ Wrapping<usize>> for Wrapping<usize>
1.22.0[src]pub fn mul_assign(&mut self, other: &Wrapping<usize>)
[src]
pub fn mul_assign(&mut self, other: &Wrapping<usize>)
[src]Performs the *=
operation. Read more
impl MulAssign<Wrapping<i128>> for Wrapping<i128>
1.8.0[src]
impl MulAssign<Wrapping<i128>> for Wrapping<i128>
1.8.0[src]pub fn mul_assign(&mut self, other: Wrapping<i128>)
[src]
pub fn mul_assign(&mut self, other: Wrapping<i128>)
[src]Performs the *=
operation. Read more
impl MulAssign<Wrapping<i16>> for Wrapping<i16>
1.8.0[src]
impl MulAssign<Wrapping<i16>> for Wrapping<i16>
1.8.0[src]pub fn mul_assign(&mut self, other: Wrapping<i16>)
[src]
pub fn mul_assign(&mut self, other: Wrapping<i16>)
[src]Performs the *=
operation. Read more
impl MulAssign<Wrapping<i32>> for Wrapping<i32>
1.8.0[src]
impl MulAssign<Wrapping<i32>> for Wrapping<i32>
1.8.0[src]pub fn mul_assign(&mut self, other: Wrapping<i32>)
[src]
pub fn mul_assign(&mut self, other: Wrapping<i32>)
[src]Performs the *=
operation. Read more
impl MulAssign<Wrapping<i64>> for Wrapping<i64>
1.8.0[src]
impl MulAssign<Wrapping<i64>> for Wrapping<i64>
1.8.0[src]pub fn mul_assign(&mut self, other: Wrapping<i64>)
[src]
pub fn mul_assign(&mut self, other: Wrapping<i64>)
[src]Performs the *=
operation. Read more
impl MulAssign<Wrapping<i8>> for Wrapping<i8>
1.8.0[src]
impl MulAssign<Wrapping<i8>> for Wrapping<i8>
1.8.0[src]pub fn mul_assign(&mut self, other: Wrapping<i8>)
[src]
pub fn mul_assign(&mut self, other: Wrapping<i8>)
[src]Performs the *=
operation. Read more
impl MulAssign<Wrapping<isize>> for Wrapping<isize>
1.8.0[src]
impl MulAssign<Wrapping<isize>> for Wrapping<isize>
1.8.0[src]pub fn mul_assign(&mut self, other: Wrapping<isize>)
[src]
pub fn mul_assign(&mut self, other: Wrapping<isize>)
[src]Performs the *=
operation. Read more
impl MulAssign<Wrapping<u128>> for Wrapping<u128>
1.8.0[src]
impl MulAssign<Wrapping<u128>> for Wrapping<u128>
1.8.0[src]pub fn mul_assign(&mut self, other: Wrapping<u128>)
[src]
pub fn mul_assign(&mut self, other: Wrapping<u128>)
[src]Performs the *=
operation. Read more
impl MulAssign<Wrapping<u16>> for Wrapping<u16>
1.8.0[src]
impl MulAssign<Wrapping<u16>> for Wrapping<u16>
1.8.0[src]pub fn mul_assign(&mut self, other: Wrapping<u16>)
[src]
pub fn mul_assign(&mut self, other: Wrapping<u16>)
[src]Performs the *=
operation. Read more
impl MulAssign<Wrapping<u32>> for Wrapping<u32>
1.8.0[src]
impl MulAssign<Wrapping<u32>> for Wrapping<u32>
1.8.0[src]pub fn mul_assign(&mut self, other: Wrapping<u32>)
[src]
pub fn mul_assign(&mut self, other: Wrapping<u32>)
[src]Performs the *=
operation. Read more
impl MulAssign<Wrapping<u64>> for Wrapping<u64>
1.8.0[src]
impl MulAssign<Wrapping<u64>> for Wrapping<u64>
1.8.0[src]pub fn mul_assign(&mut self, other: Wrapping<u64>)
[src]
pub fn mul_assign(&mut self, other: Wrapping<u64>)
[src]Performs the *=
operation. Read more
impl MulAssign<Wrapping<u8>> for Wrapping<u8>
1.8.0[src]
impl MulAssign<Wrapping<u8>> for Wrapping<u8>
1.8.0[src]pub fn mul_assign(&mut self, other: Wrapping<u8>)
[src]
pub fn mul_assign(&mut self, other: Wrapping<u8>)
[src]Performs the *=
operation. Read more
impl MulAssign<Wrapping<usize>> for Wrapping<usize>
1.8.0[src]
impl MulAssign<Wrapping<usize>> for Wrapping<usize>
1.8.0[src]pub fn mul_assign(&mut self, other: Wrapping<usize>)
[src]
pub fn mul_assign(&mut self, other: Wrapping<usize>)
[src]Performs the *=
operation. Read more
impl<T> Num for Wrapping<T> where
T: Num,
Wrapping<T>: Mul<Wrapping<T>>,
Wrapping<T>: Add<Wrapping<T>>,
Wrapping<T>: Div<Wrapping<T>>,
Wrapping<T>: Rem<Wrapping<T>>,
Wrapping<T>: Sub<Wrapping<T>>,
<Wrapping<T> as Add<Wrapping<T>>>::Output == Wrapping<T>,
<Wrapping<T> as Sub<Wrapping<T>>>::Output == Wrapping<T>,
<Wrapping<T> as Mul<Wrapping<T>>>::Output == Wrapping<T>,
<Wrapping<T> as Div<Wrapping<T>>>::Output == Wrapping<T>,
<Wrapping<T> as Rem<Wrapping<T>>>::Output == Wrapping<T>,
[src]
impl<T> Num for Wrapping<T> where
T: Num,
Wrapping<T>: Mul<Wrapping<T>>,
Wrapping<T>: Add<Wrapping<T>>,
Wrapping<T>: Div<Wrapping<T>>,
Wrapping<T>: Rem<Wrapping<T>>,
Wrapping<T>: Sub<Wrapping<T>>,
<Wrapping<T> as Add<Wrapping<T>>>::Output == Wrapping<T>,
<Wrapping<T> as Sub<Wrapping<T>>>::Output == Wrapping<T>,
<Wrapping<T> as Mul<Wrapping<T>>>::Output == Wrapping<T>,
<Wrapping<T> as Div<Wrapping<T>>>::Output == Wrapping<T>,
<Wrapping<T> as Rem<Wrapping<T>>>::Output == Wrapping<T>,
[src]type FromStrRadixErr = <T as Num>::FromStrRadixErr
pub fn from_str_radix(
str: &str,
radix: u32
) -> Result<Wrapping<T>, <Wrapping<T> as Num>::FromStrRadixErr>
[src]
pub fn from_str_radix(
str: &str,
radix: u32
) -> Result<Wrapping<T>, <Wrapping<T> as Num>::FromStrRadixErr>
[src]Convert from a string and radix (typically 2..=36
). Read more
impl<T> One for Wrapping<T> where
T: One,
Wrapping<T>: Mul<Wrapping<T>>,
<Wrapping<T> as Mul<Wrapping<T>>>::Output == Wrapping<T>,
[src]
impl<T> One for Wrapping<T> where
T: One,
Wrapping<T>: Mul<Wrapping<T>>,
<Wrapping<T> as Mul<Wrapping<T>>>::Output == Wrapping<T>,
[src]impl<T> Ord for Wrapping<T> where
T: Ord,
[src]
impl<T> Ord for Wrapping<T> where
T: Ord,
[src]impl<T> PartialOrd<Wrapping<T>> for Wrapping<T> where
T: PartialOrd<T>,
[src]
impl<T> PartialOrd<Wrapping<T>> for Wrapping<T> where
T: PartialOrd<T>,
[src]pub fn partial_cmp(&self, other: &Wrapping<T>) -> Option<Ordering>
[src]
pub fn partial_cmp(&self, other: &Wrapping<T>) -> Option<Ordering>
[src]This method returns an ordering between self
and other
values if one exists. Read more
#[must_use]fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]fn lt(&self, other: &Rhs) -> bool
[src]This method tests less than (for self
and other
) and is used by the <
operator. Read more
#[must_use]fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]fn le(&self, other: &Rhs) -> bool
[src]This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
impl<'_> RemAssign<&'_ Wrapping<i128>> for Wrapping<i128>
1.22.0[src]
impl<'_> RemAssign<&'_ Wrapping<i128>> for Wrapping<i128>
1.22.0[src]pub fn rem_assign(&mut self, other: &Wrapping<i128>)
[src]
pub fn rem_assign(&mut self, other: &Wrapping<i128>)
[src]Performs the %=
operation. Read more
impl<'_> RemAssign<&'_ Wrapping<i16>> for Wrapping<i16>
1.22.0[src]
impl<'_> RemAssign<&'_ Wrapping<i16>> for Wrapping<i16>
1.22.0[src]pub fn rem_assign(&mut self, other: &Wrapping<i16>)
[src]
pub fn rem_assign(&mut self, other: &Wrapping<i16>)
[src]Performs the %=
operation. Read more
impl<'_> RemAssign<&'_ Wrapping<i32>> for Wrapping<i32>
1.22.0[src]
impl<'_> RemAssign<&'_ Wrapping<i32>> for Wrapping<i32>
1.22.0[src]pub fn rem_assign(&mut self, other: &Wrapping<i32>)
[src]
pub fn rem_assign(&mut self, other: &Wrapping<i32>)
[src]Performs the %=
operation. Read more
impl<'_> RemAssign<&'_ Wrapping<i64>> for Wrapping<i64>
1.22.0[src]
impl<'_> RemAssign<&'_ Wrapping<i64>> for Wrapping<i64>
1.22.0[src]pub fn rem_assign(&mut self, other: &Wrapping<i64>)
[src]
pub fn rem_assign(&mut self, other: &Wrapping<i64>)
[src]Performs the %=
operation. Read more
impl<'_> RemAssign<&'_ Wrapping<i8>> for Wrapping<i8>
1.22.0[src]
impl<'_> RemAssign<&'_ Wrapping<i8>> for Wrapping<i8>
1.22.0[src]pub fn rem_assign(&mut self, other: &Wrapping<i8>)
[src]
pub fn rem_assign(&mut self, other: &Wrapping<i8>)
[src]Performs the %=
operation. Read more
impl<'_> RemAssign<&'_ Wrapping<isize>> for Wrapping<isize>
1.22.0[src]
impl<'_> RemAssign<&'_ Wrapping<isize>> for Wrapping<isize>
1.22.0[src]pub fn rem_assign(&mut self, other: &Wrapping<isize>)
[src]
pub fn rem_assign(&mut self, other: &Wrapping<isize>)
[src]Performs the %=
operation. Read more
impl<'_> RemAssign<&'_ Wrapping<u128>> for Wrapping<u128>
1.22.0[src]
impl<'_> RemAssign<&'_ Wrapping<u128>> for Wrapping<u128>
1.22.0[src]pub fn rem_assign(&mut self, other: &Wrapping<u128>)
[src]
pub fn rem_assign(&mut self, other: &Wrapping<u128>)
[src]Performs the %=
operation. Read more
impl<'_> RemAssign<&'_ Wrapping<u16>> for Wrapping<u16>
1.22.0[src]
impl<'_> RemAssign<&'_ Wrapping<u16>> for Wrapping<u16>
1.22.0[src]pub fn rem_assign(&mut self, other: &Wrapping<u16>)
[src]
pub fn rem_assign(&mut self, other: &Wrapping<u16>)
[src]Performs the %=
operation. Read more
impl<'_> RemAssign<&'_ Wrapping<u32>> for Wrapping<u32>
1.22.0[src]
impl<'_> RemAssign<&'_ Wrapping<u32>> for Wrapping<u32>
1.22.0[src]pub fn rem_assign(&mut self, other: &Wrapping<u32>)
[src]
pub fn rem_assign(&mut self, other: &Wrapping<u32>)
[src]Performs the %=
operation. Read more
impl<'_> RemAssign<&'_ Wrapping<u64>> for Wrapping<u64>
1.22.0[src]
impl<'_> RemAssign<&'_ Wrapping<u64>> for Wrapping<u64>
1.22.0[src]pub fn rem_assign(&mut self, other: &Wrapping<u64>)
[src]
pub fn rem_assign(&mut self, other: &Wrapping<u64>)
[src]Performs the %=
operation. Read more
impl<'_> RemAssign<&'_ Wrapping<u8>> for Wrapping<u8>
1.22.0[src]
impl<'_> RemAssign<&'_ Wrapping<u8>> for Wrapping<u8>
1.22.0[src]pub fn rem_assign(&mut self, other: &Wrapping<u8>)
[src]
pub fn rem_assign(&mut self, other: &Wrapping<u8>)
[src]Performs the %=
operation. Read more
impl<'_> RemAssign<&'_ Wrapping<usize>> for Wrapping<usize>
1.22.0[src]
impl<'_> RemAssign<&'_ Wrapping<usize>> for Wrapping<usize>
1.22.0[src]pub fn rem_assign(&mut self, other: &Wrapping<usize>)
[src]
pub fn rem_assign(&mut self, other: &Wrapping<usize>)
[src]Performs the %=
operation. Read more
impl RemAssign<Wrapping<i128>> for Wrapping<i128>
1.8.0[src]
impl RemAssign<Wrapping<i128>> for Wrapping<i128>
1.8.0[src]pub fn rem_assign(&mut self, other: Wrapping<i128>)
[src]
pub fn rem_assign(&mut self, other: Wrapping<i128>)
[src]Performs the %=
operation. Read more
impl RemAssign<Wrapping<i16>> for Wrapping<i16>
1.8.0[src]
impl RemAssign<Wrapping<i16>> for Wrapping<i16>
1.8.0[src]pub fn rem_assign(&mut self, other: Wrapping<i16>)
[src]
pub fn rem_assign(&mut self, other: Wrapping<i16>)
[src]Performs the %=
operation. Read more
impl RemAssign<Wrapping<i32>> for Wrapping<i32>
1.8.0[src]
impl RemAssign<Wrapping<i32>> for Wrapping<i32>
1.8.0[src]pub fn rem_assign(&mut self, other: Wrapping<i32>)
[src]
pub fn rem_assign(&mut self, other: Wrapping<i32>)
[src]Performs the %=
operation. Read more
impl RemAssign<Wrapping<i64>> for Wrapping<i64>
1.8.0[src]
impl RemAssign<Wrapping<i64>> for Wrapping<i64>
1.8.0[src]pub fn rem_assign(&mut self, other: Wrapping<i64>)
[src]
pub fn rem_assign(&mut self, other: Wrapping<i64>)
[src]Performs the %=
operation. Read more
impl RemAssign<Wrapping<i8>> for Wrapping<i8>
1.8.0[src]
impl RemAssign<Wrapping<i8>> for Wrapping<i8>
1.8.0[src]pub fn rem_assign(&mut self, other: Wrapping<i8>)
[src]
pub fn rem_assign(&mut self, other: Wrapping<i8>)
[src]Performs the %=
operation. Read more
impl RemAssign<Wrapping<isize>> for Wrapping<isize>
1.8.0[src]
impl RemAssign<Wrapping<isize>> for Wrapping<isize>
1.8.0[src]pub fn rem_assign(&mut self, other: Wrapping<isize>)
[src]
pub fn rem_assign(&mut self, other: Wrapping<isize>)
[src]Performs the %=
operation. Read more
impl RemAssign<Wrapping<u128>> for Wrapping<u128>
1.8.0[src]
impl RemAssign<Wrapping<u128>> for Wrapping<u128>
1.8.0[src]pub fn rem_assign(&mut self, other: Wrapping<u128>)
[src]
pub fn rem_assign(&mut self, other: Wrapping<u128>)
[src]Performs the %=
operation. Read more
impl RemAssign<Wrapping<u16>> for Wrapping<u16>
1.8.0[src]
impl RemAssign<Wrapping<u16>> for Wrapping<u16>
1.8.0[src]pub fn rem_assign(&mut self, other: Wrapping<u16>)
[src]
pub fn rem_assign(&mut self, other: Wrapping<u16>)
[src]Performs the %=
operation. Read more
impl RemAssign<Wrapping<u32>> for Wrapping<u32>
1.8.0[src]
impl RemAssign<Wrapping<u32>> for Wrapping<u32>
1.8.0[src]pub fn rem_assign(&mut self, other: Wrapping<u32>)
[src]
pub fn rem_assign(&mut self, other: Wrapping<u32>)
[src]Performs the %=
operation. Read more
impl RemAssign<Wrapping<u64>> for Wrapping<u64>
1.8.0[src]
impl RemAssign<Wrapping<u64>> for Wrapping<u64>
1.8.0[src]pub fn rem_assign(&mut self, other: Wrapping<u64>)
[src]
pub fn rem_assign(&mut self, other: Wrapping<u64>)
[src]Performs the %=
operation. Read more
impl RemAssign<Wrapping<u8>> for Wrapping<u8>
1.8.0[src]
impl RemAssign<Wrapping<u8>> for Wrapping<u8>
1.8.0[src]pub fn rem_assign(&mut self, other: Wrapping<u8>)
[src]
pub fn rem_assign(&mut self, other: Wrapping<u8>)
[src]Performs the %=
operation. Read more
impl RemAssign<Wrapping<usize>> for Wrapping<usize>
1.8.0[src]
impl RemAssign<Wrapping<usize>> for Wrapping<usize>
1.8.0[src]pub fn rem_assign(&mut self, other: Wrapping<usize>)
[src]
pub fn rem_assign(&mut self, other: Wrapping<usize>)
[src]Performs the %=
operation. Read more
impl<T> Serialize for Wrapping<T> where
T: Serialize,
[src]
impl<T> Serialize for Wrapping<T> where
T: Serialize,
[src]pub fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
S: Serializer,
[src]
pub fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
S: Serializer,
[src]Serialize this value into the given Serde serializer. Read more
impl<'_> ShlAssign<&'_ usize> for Wrapping<u128>
1.22.0[src]
impl<'_> ShlAssign<&'_ usize> for Wrapping<u128>
1.22.0[src]pub fn shl_assign(&mut self, other: &usize)
[src]
pub fn shl_assign(&mut self, other: &usize)
[src]Performs the <<=
operation. Read more
impl<'_> ShlAssign<&'_ usize> for Wrapping<usize>
1.22.0[src]
impl<'_> ShlAssign<&'_ usize> for Wrapping<usize>
1.22.0[src]pub fn shl_assign(&mut self, other: &usize)
[src]
pub fn shl_assign(&mut self, other: &usize)
[src]Performs the <<=
operation. Read more
impl<'_> ShlAssign<&'_ usize> for Wrapping<i128>
1.22.0[src]
impl<'_> ShlAssign<&'_ usize> for Wrapping<i128>
1.22.0[src]pub fn shl_assign(&mut self, other: &usize)
[src]
pub fn shl_assign(&mut self, other: &usize)
[src]Performs the <<=
operation. Read more
impl<'_> ShlAssign<&'_ usize> for Wrapping<u16>
1.22.0[src]
impl<'_> ShlAssign<&'_ usize> for Wrapping<u16>
1.22.0[src]pub fn shl_assign(&mut self, other: &usize)
[src]
pub fn shl_assign(&mut self, other: &usize)
[src]Performs the <<=
operation. Read more
impl<'_> ShlAssign<&'_ usize> for Wrapping<i64>
1.22.0[src]
impl<'_> ShlAssign<&'_ usize> for Wrapping<i64>
1.22.0[src]pub fn shl_assign(&mut self, other: &usize)
[src]
pub fn shl_assign(&mut self, other: &usize)
[src]Performs the <<=
operation. Read more
impl<'_> ShlAssign<&'_ usize> for Wrapping<u8>
1.22.0[src]
impl<'_> ShlAssign<&'_ usize> for Wrapping<u8>
1.22.0[src]pub fn shl_assign(&mut self, other: &usize)
[src]
pub fn shl_assign(&mut self, other: &usize)
[src]Performs the <<=
operation. Read more
impl<'_> ShlAssign<&'_ usize> for Wrapping<i32>
1.22.0[src]
impl<'_> ShlAssign<&'_ usize> for Wrapping<i32>
1.22.0[src]pub fn shl_assign(&mut self, other: &usize)
[src]
pub fn shl_assign(&mut self, other: &usize)
[src]Performs the <<=
operation. Read more
impl<'_> ShlAssign<&'_ usize> for Wrapping<isize>
1.22.0[src]
impl<'_> ShlAssign<&'_ usize> for Wrapping<isize>
1.22.0[src]pub fn shl_assign(&mut self, other: &usize)
[src]
pub fn shl_assign(&mut self, other: &usize)
[src]Performs the <<=
operation. Read more
impl<'_> ShlAssign<&'_ usize> for Wrapping<i8>
1.22.0[src]
impl<'_> ShlAssign<&'_ usize> for Wrapping<i8>
1.22.0[src]pub fn shl_assign(&mut self, other: &usize)
[src]
pub fn shl_assign(&mut self, other: &usize)
[src]Performs the <<=
operation. Read more
impl<'_> ShlAssign<&'_ usize> for Wrapping<u64>
1.22.0[src]
impl<'_> ShlAssign<&'_ usize> for Wrapping<u64>
1.22.0[src]pub fn shl_assign(&mut self, other: &usize)
[src]
pub fn shl_assign(&mut self, other: &usize)
[src]Performs the <<=
operation. Read more
impl<'_> ShlAssign<&'_ usize> for Wrapping<i16>
1.22.0[src]
impl<'_> ShlAssign<&'_ usize> for Wrapping<i16>
1.22.0[src]pub fn shl_assign(&mut self, other: &usize)
[src]
pub fn shl_assign(&mut self, other: &usize)
[src]Performs the <<=
operation. Read more
impl<'_> ShlAssign<&'_ usize> for Wrapping<u32>
1.22.0[src]
impl<'_> ShlAssign<&'_ usize> for Wrapping<u32>
1.22.0[src]pub fn shl_assign(&mut self, other: &usize)
[src]
pub fn shl_assign(&mut self, other: &usize)
[src]Performs the <<=
operation. Read more
impl ShlAssign<usize> for Wrapping<i64>
1.8.0[src]
impl ShlAssign<usize> for Wrapping<i64>
1.8.0[src]pub fn shl_assign(&mut self, other: usize)
[src]
pub fn shl_assign(&mut self, other: usize)
[src]Performs the <<=
operation. Read more
impl ShlAssign<usize> for Wrapping<u16>
1.8.0[src]
impl ShlAssign<usize> for Wrapping<u16>
1.8.0[src]pub fn shl_assign(&mut self, other: usize)
[src]
pub fn shl_assign(&mut self, other: usize)
[src]Performs the <<=
operation. Read more
impl ShlAssign<usize> for Wrapping<isize>
1.8.0[src]
impl ShlAssign<usize> for Wrapping<isize>
1.8.0[src]pub fn shl_assign(&mut self, other: usize)
[src]
pub fn shl_assign(&mut self, other: usize)
[src]Performs the <<=
operation. Read more
impl ShlAssign<usize> for Wrapping<i16>
1.8.0[src]
impl ShlAssign<usize> for Wrapping<i16>
1.8.0[src]pub fn shl_assign(&mut self, other: usize)
[src]
pub fn shl_assign(&mut self, other: usize)
[src]Performs the <<=
operation. Read more
impl ShlAssign<usize> for Wrapping<u8>
1.8.0[src]
impl ShlAssign<usize> for Wrapping<u8>
1.8.0[src]pub fn shl_assign(&mut self, other: usize)
[src]
pub fn shl_assign(&mut self, other: usize)
[src]Performs the <<=
operation. Read more
impl ShlAssign<usize> for Wrapping<i32>
1.8.0[src]
impl ShlAssign<usize> for Wrapping<i32>
1.8.0[src]pub fn shl_assign(&mut self, other: usize)
[src]
pub fn shl_assign(&mut self, other: usize)
[src]Performs the <<=
operation. Read more
impl ShlAssign<usize> for Wrapping<u32>
1.8.0[src]
impl ShlAssign<usize> for Wrapping<u32>
1.8.0[src]pub fn shl_assign(&mut self, other: usize)
[src]
pub fn shl_assign(&mut self, other: usize)
[src]Performs the <<=
operation. Read more
impl ShlAssign<usize> for Wrapping<u64>
1.8.0[src]
impl ShlAssign<usize> for Wrapping<u64>
1.8.0[src]pub fn shl_assign(&mut self, other: usize)
[src]
pub fn shl_assign(&mut self, other: usize)
[src]Performs the <<=
operation. Read more
impl ShlAssign<usize> for Wrapping<i8>
1.8.0[src]
impl ShlAssign<usize> for Wrapping<i8>
1.8.0[src]pub fn shl_assign(&mut self, other: usize)
[src]
pub fn shl_assign(&mut self, other: usize)
[src]Performs the <<=
operation. Read more
impl ShlAssign<usize> for Wrapping<u128>
1.8.0[src]
impl ShlAssign<usize> for Wrapping<u128>
1.8.0[src]pub fn shl_assign(&mut self, other: usize)
[src]
pub fn shl_assign(&mut self, other: usize)
[src]Performs the <<=
operation. Read more
impl ShlAssign<usize> for Wrapping<i128>
1.8.0[src]
impl ShlAssign<usize> for Wrapping<i128>
1.8.0[src]pub fn shl_assign(&mut self, other: usize)
[src]
pub fn shl_assign(&mut self, other: usize)
[src]Performs the <<=
operation. Read more
impl ShlAssign<usize> for Wrapping<usize>
1.8.0[src]
impl ShlAssign<usize> for Wrapping<usize>
1.8.0[src]pub fn shl_assign(&mut self, other: usize)
[src]
pub fn shl_assign(&mut self, other: usize)
[src]Performs the <<=
operation. Read more
impl<'_> ShrAssign<&'_ usize> for Wrapping<u16>
1.22.0[src]
impl<'_> ShrAssign<&'_ usize> for Wrapping<u16>
1.22.0[src]pub fn shr_assign(&mut self, other: &usize)
[src]
pub fn shr_assign(&mut self, other: &usize)
[src]Performs the >>=
operation. Read more
impl<'_> ShrAssign<&'_ usize> for Wrapping<usize>
1.22.0[src]
impl<'_> ShrAssign<&'_ usize> for Wrapping<usize>
1.22.0[src]pub fn shr_assign(&mut self, other: &usize)
[src]
pub fn shr_assign(&mut self, other: &usize)
[src]Performs the >>=
operation. Read more
impl<'_> ShrAssign<&'_ usize> for Wrapping<u128>
1.22.0[src]
impl<'_> ShrAssign<&'_ usize> for Wrapping<u128>
1.22.0[src]pub fn shr_assign(&mut self, other: &usize)
[src]
pub fn shr_assign(&mut self, other: &usize)
[src]Performs the >>=
operation. Read more
impl<'_> ShrAssign<&'_ usize> for Wrapping<isize>
1.22.0[src]
impl<'_> ShrAssign<&'_ usize> for Wrapping<isize>
1.22.0[src]pub fn shr_assign(&mut self, other: &usize)
[src]
pub fn shr_assign(&mut self, other: &usize)
[src]Performs the >>=
operation. Read more
impl<'_> ShrAssign<&'_ usize> for Wrapping<i32>
1.22.0[src]
impl<'_> ShrAssign<&'_ usize> for Wrapping<i32>
1.22.0[src]pub fn shr_assign(&mut self, other: &usize)
[src]
pub fn shr_assign(&mut self, other: &usize)
[src]Performs the >>=
operation. Read more
impl<'_> ShrAssign<&'_ usize> for Wrapping<i64>
1.22.0[src]
impl<'_> ShrAssign<&'_ usize> for Wrapping<i64>
1.22.0[src]pub fn shr_assign(&mut self, other: &usize)
[src]
pub fn shr_assign(&mut self, other: &usize)
[src]Performs the >>=
operation. Read more
impl<'_> ShrAssign<&'_ usize> for Wrapping<i8>
1.22.0[src]
impl<'_> ShrAssign<&'_ usize> for Wrapping<i8>
1.22.0[src]pub fn shr_assign(&mut self, other: &usize)
[src]
pub fn shr_assign(&mut self, other: &usize)
[src]Performs the >>=
operation. Read more
impl<'_> ShrAssign<&'_ usize> for Wrapping<u32>
1.22.0[src]
impl<'_> ShrAssign<&'_ usize> for Wrapping<u32>
1.22.0[src]pub fn shr_assign(&mut self, other: &usize)
[src]
pub fn shr_assign(&mut self, other: &usize)
[src]Performs the >>=
operation. Read more
impl<'_> ShrAssign<&'_ usize> for Wrapping<u64>
1.22.0[src]
impl<'_> ShrAssign<&'_ usize> for Wrapping<u64>
1.22.0[src]pub fn shr_assign(&mut self, other: &usize)
[src]
pub fn shr_assign(&mut self, other: &usize)
[src]Performs the >>=
operation. Read more
impl<'_> ShrAssign<&'_ usize> for Wrapping<u8>
1.22.0[src]
impl<'_> ShrAssign<&'_ usize> for Wrapping<u8>
1.22.0[src]pub fn shr_assign(&mut self, other: &usize)
[src]
pub fn shr_assign(&mut self, other: &usize)
[src]Performs the >>=
operation. Read more
impl<'_> ShrAssign<&'_ usize> for Wrapping<i16>
1.22.0[src]
impl<'_> ShrAssign<&'_ usize> for Wrapping<i16>
1.22.0[src]pub fn shr_assign(&mut self, other: &usize)
[src]
pub fn shr_assign(&mut self, other: &usize)
[src]Performs the >>=
operation. Read more
impl<'_> ShrAssign<&'_ usize> for Wrapping<i128>
1.22.0[src]
impl<'_> ShrAssign<&'_ usize> for Wrapping<i128>
1.22.0[src]pub fn shr_assign(&mut self, other: &usize)
[src]
pub fn shr_assign(&mut self, other: &usize)
[src]Performs the >>=
operation. Read more
impl ShrAssign<usize> for Wrapping<i32>
1.8.0[src]
impl ShrAssign<usize> for Wrapping<i32>
1.8.0[src]pub fn shr_assign(&mut self, other: usize)
[src]
pub fn shr_assign(&mut self, other: usize)
[src]Performs the >>=
operation. Read more
impl ShrAssign<usize> for Wrapping<i8>
1.8.0[src]
impl ShrAssign<usize> for Wrapping<i8>
1.8.0[src]pub fn shr_assign(&mut self, other: usize)
[src]
pub fn shr_assign(&mut self, other: usize)
[src]Performs the >>=
operation. Read more
impl ShrAssign<usize> for Wrapping<isize>
1.8.0[src]
impl ShrAssign<usize> for Wrapping<isize>
1.8.0[src]pub fn shr_assign(&mut self, other: usize)
[src]
pub fn shr_assign(&mut self, other: usize)
[src]Performs the >>=
operation. Read more
impl ShrAssign<usize> for Wrapping<i128>
1.8.0[src]
impl ShrAssign<usize> for Wrapping<i128>
1.8.0[src]pub fn shr_assign(&mut self, other: usize)
[src]
pub fn shr_assign(&mut self, other: usize)
[src]Performs the >>=
operation. Read more
impl ShrAssign<usize> for Wrapping<usize>
1.8.0[src]
impl ShrAssign<usize> for Wrapping<usize>
1.8.0[src]pub fn shr_assign(&mut self, other: usize)
[src]
pub fn shr_assign(&mut self, other: usize)
[src]Performs the >>=
operation. Read more
impl ShrAssign<usize> for Wrapping<u16>
1.8.0[src]
impl ShrAssign<usize> for Wrapping<u16>
1.8.0[src]pub fn shr_assign(&mut self, other: usize)
[src]
pub fn shr_assign(&mut self, other: usize)
[src]Performs the >>=
operation. Read more
impl ShrAssign<usize> for Wrapping<u32>
1.8.0[src]
impl ShrAssign<usize> for Wrapping<u32>
1.8.0[src]pub fn shr_assign(&mut self, other: usize)
[src]
pub fn shr_assign(&mut self, other: usize)
[src]Performs the >>=
operation. Read more
impl ShrAssign<usize> for Wrapping<u128>
1.8.0[src]
impl ShrAssign<usize> for Wrapping<u128>
1.8.0[src]pub fn shr_assign(&mut self, other: usize)
[src]
pub fn shr_assign(&mut self, other: usize)
[src]Performs the >>=
operation. Read more
impl ShrAssign<usize> for Wrapping<u64>
1.8.0[src]
impl ShrAssign<usize> for Wrapping<u64>
1.8.0[src]pub fn shr_assign(&mut self, other: usize)
[src]
pub fn shr_assign(&mut self, other: usize)
[src]Performs the >>=
operation. Read more
impl ShrAssign<usize> for Wrapping<u8>
1.8.0[src]
impl ShrAssign<usize> for Wrapping<u8>
1.8.0[src]pub fn shr_assign(&mut self, other: usize)
[src]
pub fn shr_assign(&mut self, other: usize)
[src]Performs the >>=
operation. Read more
impl ShrAssign<usize> for Wrapping<i64>
1.8.0[src]
impl ShrAssign<usize> for Wrapping<i64>
1.8.0[src]pub fn shr_assign(&mut self, other: usize)
[src]
pub fn shr_assign(&mut self, other: usize)
[src]Performs the >>=
operation. Read more
impl ShrAssign<usize> for Wrapping<i16>
1.8.0[src]
impl ShrAssign<usize> for Wrapping<i16>
1.8.0[src]pub fn shr_assign(&mut self, other: usize)
[src]
pub fn shr_assign(&mut self, other: usize)
[src]Performs the >>=
operation. Read more
impl<T> Signed for Wrapping<T> where
T: Signed,
Wrapping<T>: Num,
Wrapping<T>: Neg,
<Wrapping<T> as Neg>::Output == Wrapping<T>,
[src]
impl<T> Signed for Wrapping<T> where
T: Signed,
Wrapping<T>: Num,
Wrapping<T>: Neg,
<Wrapping<T> as Neg>::Output == Wrapping<T>,
[src]pub fn abs_sub(&self, other: &Wrapping<T>) -> Wrapping<T>
[src]
pub fn abs_sub(&self, other: &Wrapping<T>) -> Wrapping<T>
[src]The positive difference of two numbers. Read more
pub fn is_positive(&self) -> bool
[src]
pub fn is_positive(&self) -> bool
[src]Returns true if the number is positive and false if the number is zero or negative.
pub fn is_negative(&self) -> bool
[src]
pub fn is_negative(&self) -> bool
[src]Returns true if the number is negative and false if the number is zero or positive.
impl<'_> SubAssign<&'_ Wrapping<i128>> for Wrapping<i128>
1.22.0[src]
impl<'_> SubAssign<&'_ Wrapping<i128>> for Wrapping<i128>
1.22.0[src]pub fn sub_assign(&mut self, other: &Wrapping<i128>)
[src]
pub fn sub_assign(&mut self, other: &Wrapping<i128>)
[src]Performs the -=
operation. Read more
impl<'_> SubAssign<&'_ Wrapping<i16>> for Wrapping<i16>
1.22.0[src]
impl<'_> SubAssign<&'_ Wrapping<i16>> for Wrapping<i16>
1.22.0[src]pub fn sub_assign(&mut self, other: &Wrapping<i16>)
[src]
pub fn sub_assign(&mut self, other: &Wrapping<i16>)
[src]Performs the -=
operation. Read more
impl<'_> SubAssign<&'_ Wrapping<i32>> for Wrapping<i32>
1.22.0[src]
impl<'_> SubAssign<&'_ Wrapping<i32>> for Wrapping<i32>
1.22.0[src]pub fn sub_assign(&mut self, other: &Wrapping<i32>)
[src]
pub fn sub_assign(&mut self, other: &Wrapping<i32>)
[src]Performs the -=
operation. Read more
impl<'_> SubAssign<&'_ Wrapping<i64>> for Wrapping<i64>
1.22.0[src]
impl<'_> SubAssign<&'_ Wrapping<i64>> for Wrapping<i64>
1.22.0[src]pub fn sub_assign(&mut self, other: &Wrapping<i64>)
[src]
pub fn sub_assign(&mut self, other: &Wrapping<i64>)
[src]Performs the -=
operation. Read more
impl<'_> SubAssign<&'_ Wrapping<i8>> for Wrapping<i8>
1.22.0[src]
impl<'_> SubAssign<&'_ Wrapping<i8>> for Wrapping<i8>
1.22.0[src]pub fn sub_assign(&mut self, other: &Wrapping<i8>)
[src]
pub fn sub_assign(&mut self, other: &Wrapping<i8>)
[src]Performs the -=
operation. Read more
impl<'_> SubAssign<&'_ Wrapping<isize>> for Wrapping<isize>
1.22.0[src]
impl<'_> SubAssign<&'_ Wrapping<isize>> for Wrapping<isize>
1.22.0[src]pub fn sub_assign(&mut self, other: &Wrapping<isize>)
[src]
pub fn sub_assign(&mut self, other: &Wrapping<isize>)
[src]Performs the -=
operation. Read more
impl<'_> SubAssign<&'_ Wrapping<u128>> for Wrapping<u128>
1.22.0[src]
impl<'_> SubAssign<&'_ Wrapping<u128>> for Wrapping<u128>
1.22.0[src]pub fn sub_assign(&mut self, other: &Wrapping<u128>)
[src]
pub fn sub_assign(&mut self, other: &Wrapping<u128>)
[src]Performs the -=
operation. Read more
impl<'_> SubAssign<&'_ Wrapping<u16>> for Wrapping<u16>
1.22.0[src]
impl<'_> SubAssign<&'_ Wrapping<u16>> for Wrapping<u16>
1.22.0[src]pub fn sub_assign(&mut self, other: &Wrapping<u16>)
[src]
pub fn sub_assign(&mut self, other: &Wrapping<u16>)
[src]Performs the -=
operation. Read more
impl<'_> SubAssign<&'_ Wrapping<u32>> for Wrapping<u32>
1.22.0[src]
impl<'_> SubAssign<&'_ Wrapping<u32>> for Wrapping<u32>
1.22.0[src]pub fn sub_assign(&mut self, other: &Wrapping<u32>)
[src]
pub fn sub_assign(&mut self, other: &Wrapping<u32>)
[src]Performs the -=
operation. Read more
impl<'_> SubAssign<&'_ Wrapping<u64>> for Wrapping<u64>
1.22.0[src]
impl<'_> SubAssign<&'_ Wrapping<u64>> for Wrapping<u64>
1.22.0[src]pub fn sub_assign(&mut self, other: &Wrapping<u64>)
[src]
pub fn sub_assign(&mut self, other: &Wrapping<u64>)
[src]Performs the -=
operation. Read more
impl<'_> SubAssign<&'_ Wrapping<u8>> for Wrapping<u8>
1.22.0[src]
impl<'_> SubAssign<&'_ Wrapping<u8>> for Wrapping<u8>
1.22.0[src]pub fn sub_assign(&mut self, other: &Wrapping<u8>)
[src]
pub fn sub_assign(&mut self, other: &Wrapping<u8>)
[src]Performs the -=
operation. Read more
impl<'_> SubAssign<&'_ Wrapping<usize>> for Wrapping<usize>
1.22.0[src]
impl<'_> SubAssign<&'_ Wrapping<usize>> for Wrapping<usize>
1.22.0[src]pub fn sub_assign(&mut self, other: &Wrapping<usize>)
[src]
pub fn sub_assign(&mut self, other: &Wrapping<usize>)
[src]Performs the -=
operation. Read more
impl SubAssign<Wrapping<i128>> for Wrapping<i128>
1.8.0[src]
impl SubAssign<Wrapping<i128>> for Wrapping<i128>
1.8.0[src]pub fn sub_assign(&mut self, other: Wrapping<i128>)
[src]
pub fn sub_assign(&mut self, other: Wrapping<i128>)
[src]Performs the -=
operation. Read more
impl SubAssign<Wrapping<i16>> for Wrapping<i16>
1.8.0[src]
impl SubAssign<Wrapping<i16>> for Wrapping<i16>
1.8.0[src]pub fn sub_assign(&mut self, other: Wrapping<i16>)
[src]
pub fn sub_assign(&mut self, other: Wrapping<i16>)
[src]Performs the -=
operation. Read more
impl SubAssign<Wrapping<i32>> for Wrapping<i32>
1.8.0[src]
impl SubAssign<Wrapping<i32>> for Wrapping<i32>
1.8.0[src]pub fn sub_assign(&mut self, other: Wrapping<i32>)
[src]
pub fn sub_assign(&mut self, other: Wrapping<i32>)
[src]Performs the -=
operation. Read more
impl SubAssign<Wrapping<i64>> for Wrapping<i64>
1.8.0[src]
impl SubAssign<Wrapping<i64>> for Wrapping<i64>
1.8.0[src]pub fn sub_assign(&mut self, other: Wrapping<i64>)
[src]
pub fn sub_assign(&mut self, other: Wrapping<i64>)
[src]Performs the -=
operation. Read more
impl SubAssign<Wrapping<i8>> for Wrapping<i8>
1.8.0[src]
impl SubAssign<Wrapping<i8>> for Wrapping<i8>
1.8.0[src]pub fn sub_assign(&mut self, other: Wrapping<i8>)
[src]
pub fn sub_assign(&mut self, other: Wrapping<i8>)
[src]Performs the -=
operation. Read more
impl SubAssign<Wrapping<isize>> for Wrapping<isize>
1.8.0[src]
impl SubAssign<Wrapping<isize>> for Wrapping<isize>
1.8.0[src]pub fn sub_assign(&mut self, other: Wrapping<isize>)
[src]
pub fn sub_assign(&mut self, other: Wrapping<isize>)
[src]Performs the -=
operation. Read more
impl SubAssign<Wrapping<u128>> for Wrapping<u128>
1.8.0[src]
impl SubAssign<Wrapping<u128>> for Wrapping<u128>
1.8.0[src]pub fn sub_assign(&mut self, other: Wrapping<u128>)
[src]
pub fn sub_assign(&mut self, other: Wrapping<u128>)
[src]Performs the -=
operation. Read more
impl SubAssign<Wrapping<u16>> for Wrapping<u16>
1.8.0[src]
impl SubAssign<Wrapping<u16>> for Wrapping<u16>
1.8.0[src]pub fn sub_assign(&mut self, other: Wrapping<u16>)
[src]
pub fn sub_assign(&mut self, other: Wrapping<u16>)
[src]Performs the -=
operation. Read more
impl SubAssign<Wrapping<u32>> for Wrapping<u32>
1.8.0[src]
impl SubAssign<Wrapping<u32>> for Wrapping<u32>
1.8.0[src]pub fn sub_assign(&mut self, other: Wrapping<u32>)
[src]
pub fn sub_assign(&mut self, other: Wrapping<u32>)
[src]Performs the -=
operation. Read more
impl SubAssign<Wrapping<u64>> for Wrapping<u64>
1.8.0[src]
impl SubAssign<Wrapping<u64>> for Wrapping<u64>
1.8.0[src]pub fn sub_assign(&mut self, other: Wrapping<u64>)
[src]
pub fn sub_assign(&mut self, other: Wrapping<u64>)
[src]Performs the -=
operation. Read more
impl SubAssign<Wrapping<u8>> for Wrapping<u8>
1.8.0[src]
impl SubAssign<Wrapping<u8>> for Wrapping<u8>
1.8.0[src]pub fn sub_assign(&mut self, other: Wrapping<u8>)
[src]
pub fn sub_assign(&mut self, other: Wrapping<u8>)
[src]Performs the -=
operation. Read more
impl SubAssign<Wrapping<usize>> for Wrapping<usize>
1.8.0[src]
impl SubAssign<Wrapping<usize>> for Wrapping<usize>
1.8.0[src]pub fn sub_assign(&mut self, other: Wrapping<usize>)
[src]
pub fn sub_assign(&mut self, other: Wrapping<usize>)
[src]Performs the -=
operation. Read more
impl<T> ToPrimitive for Wrapping<T> where
T: ToPrimitive,
[src]
impl<T> ToPrimitive for Wrapping<T> where
T: ToPrimitive,
[src]pub fn to_isize(&self) -> Option<isize>
[src]
pub fn to_isize(&self) -> Option<isize>
[src]Converts the value of self
to an isize
. If the value cannot be
represented by an isize
, then None
is returned. Read more
pub fn to_i8(&self) -> Option<i8>
[src]
pub fn to_i8(&self) -> Option<i8>
[src]Converts the value of self
to an i8
. If the value cannot be
represented by an i8
, then None
is returned. Read more
pub fn to_i16(&self) -> Option<i16>
[src]
pub fn to_i16(&self) -> Option<i16>
[src]Converts the value of self
to an i16
. If the value cannot be
represented by an i16
, then None
is returned. Read more
pub fn to_i32(&self) -> Option<i32>
[src]
pub fn to_i32(&self) -> Option<i32>
[src]Converts the value of self
to an i32
. If the value cannot be
represented by an i32
, then None
is returned. Read more
pub fn to_i64(&self) -> Option<i64>
[src]
pub fn to_i64(&self) -> Option<i64>
[src]Converts the value of self
to an i64
. If the value cannot be
represented by an i64
, then None
is returned. Read more
pub fn to_i128(&self) -> Option<i128>
[src]
pub fn to_i128(&self) -> Option<i128>
[src]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. Read more
pub fn to_usize(&self) -> Option<usize>
[src]
pub fn to_usize(&self) -> Option<usize>
[src]Converts the value of self
to a usize
. If the value cannot be
represented by a usize
, then None
is returned. Read more
pub fn to_u8(&self) -> Option<u8>
[src]
pub fn to_u8(&self) -> Option<u8>
[src]Converts the value of self
to a u8
. If the value cannot be
represented by a u8
, then None
is returned. Read more
pub fn to_u16(&self) -> Option<u16>
[src]
pub fn to_u16(&self) -> Option<u16>
[src]Converts the value of self
to a u16
. If the value cannot be
represented by a u16
, then None
is returned. Read more
pub fn to_u32(&self) -> Option<u32>
[src]
pub fn to_u32(&self) -> Option<u32>
[src]Converts the value of self
to a u32
. If the value cannot be
represented by a u32
, then None
is returned. Read more
pub fn to_u64(&self) -> Option<u64>
[src]
pub fn to_u64(&self) -> Option<u64>
[src]Converts the value of self
to a u64
. If the value cannot be
represented by a u64
, then None
is returned. Read more
pub fn to_u128(&self) -> Option<u128>
[src]
pub fn to_u128(&self) -> Option<u128>
[src]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. Read more
impl<T> TransparentWrapper<T> for Wrapping<T>
impl<T> TransparentWrapper<T> for Wrapping<T>
impl<T> WrappingAdd for Wrapping<T> where
T: WrappingAdd,
Wrapping<T>: Add<Wrapping<T>>,
<Wrapping<T> as Add<Wrapping<T>>>::Output == Wrapping<T>,
[src]
impl<T> WrappingAdd for Wrapping<T> where
T: WrappingAdd,
Wrapping<T>: Add<Wrapping<T>>,
<Wrapping<T> as Add<Wrapping<T>>>::Output == Wrapping<T>,
[src]pub fn wrapping_add(&self, v: &Wrapping<T>) -> Wrapping<T>
[src]
pub fn wrapping_add(&self, v: &Wrapping<T>) -> Wrapping<T>
[src]Wrapping (modular) addition. Computes self + other
, wrapping around at the boundary of
the type. Read more
impl<T> WrappingMul for Wrapping<T> where
T: WrappingMul,
Wrapping<T>: Mul<Wrapping<T>>,
<Wrapping<T> as Mul<Wrapping<T>>>::Output == Wrapping<T>,
[src]
impl<T> WrappingMul for Wrapping<T> where
T: WrappingMul,
Wrapping<T>: Mul<Wrapping<T>>,
<Wrapping<T> as Mul<Wrapping<T>>>::Output == Wrapping<T>,
[src]pub fn wrapping_mul(&self, v: &Wrapping<T>) -> Wrapping<T>
[src]
pub fn wrapping_mul(&self, v: &Wrapping<T>) -> Wrapping<T>
[src]Wrapping (modular) multiplication. Computes self * other
, wrapping around at the boundary
of the type. Read more
impl<T> WrappingNeg for Wrapping<T> where
T: WrappingNeg,
Wrapping<T>: Neg,
<Wrapping<T> as Neg>::Output == Wrapping<T>,
[src]
impl<T> WrappingNeg for Wrapping<T> where
T: WrappingNeg,
Wrapping<T>: Neg,
<Wrapping<T> as Neg>::Output == Wrapping<T>,
[src]pub fn wrapping_neg(&self) -> Wrapping<T>
[src]
pub fn wrapping_neg(&self) -> Wrapping<T>
[src]Wrapping (modular) negation. Computes -self
,
wrapping around at the boundary of the type. Read more
impl<T> WrappingShl for Wrapping<T> where
T: WrappingShl,
Wrapping<T>: Shl<usize>,
<Wrapping<T> as Shl<usize>>::Output == Wrapping<T>,
[src]
impl<T> WrappingShl for Wrapping<T> where
T: WrappingShl,
Wrapping<T>: Shl<usize>,
<Wrapping<T> as Shl<usize>>::Output == Wrapping<T>,
[src]pub fn wrapping_shl(&self, rhs: u32) -> Wrapping<T>
[src]
pub fn wrapping_shl(&self, rhs: u32) -> Wrapping<T>
[src]Panic-free bitwise shift-left; yields self << mask(rhs)
,
where mask
removes any high order bits of rhs
that would
cause the shift to exceed the bitwidth of the type. Read more
impl<T> WrappingShr for Wrapping<T> where
T: WrappingShr,
Wrapping<T>: Shr<usize>,
<Wrapping<T> as Shr<usize>>::Output == Wrapping<T>,
[src]
impl<T> WrappingShr for Wrapping<T> where
T: WrappingShr,
Wrapping<T>: Shr<usize>,
<Wrapping<T> as Shr<usize>>::Output == Wrapping<T>,
[src]pub fn wrapping_shr(&self, rhs: u32) -> Wrapping<T>
[src]
pub fn wrapping_shr(&self, rhs: u32) -> Wrapping<T>
[src]Panic-free bitwise shift-right; yields self >> mask(rhs)
,
where mask
removes any high order bits of rhs
that would
cause the shift to exceed the bitwidth of the type. Read more
impl<T> WrappingSub for Wrapping<T> where
T: WrappingSub,
Wrapping<T>: Sub<Wrapping<T>>,
<Wrapping<T> as Sub<Wrapping<T>>>::Output == Wrapping<T>,
[src]
impl<T> WrappingSub for Wrapping<T> where
T: WrappingSub,
Wrapping<T>: Sub<Wrapping<T>>,
<Wrapping<T> as Sub<Wrapping<T>>>::Output == Wrapping<T>,
[src]pub fn wrapping_sub(&self, v: &Wrapping<T>) -> Wrapping<T>
[src]
pub fn wrapping_sub(&self, v: &Wrapping<T>) -> Wrapping<T>
[src]Wrapping (modular) subtraction. Computes self - other
, wrapping around at the boundary
of the type. Read more
impl<T> Zero for Wrapping<T> where
T: Zero,
Wrapping<T>: Add<Wrapping<T>>,
<Wrapping<T> as Add<Wrapping<T>>>::Output == Wrapping<T>,
[src]
impl<T> Zero for Wrapping<T> where
T: Zero,
Wrapping<T>: Add<Wrapping<T>>,
<Wrapping<T> as Add<Wrapping<T>>>::Output == Wrapping<T>,
[src]impl<T> Copy for Wrapping<T> where
T: Copy,
[src]
T: Copy,
impl<T> Eq for Wrapping<T> where
T: Eq,
[src]
T: Eq,
impl<T> Pod for Wrapping<T> where
T: Pod,
T: Pod,
impl<T> StructuralEq for Wrapping<T>
[src]
impl<T> StructuralPartialEq for Wrapping<T>
[src]
impl<T> Unsigned for Wrapping<T> where
T: Unsigned,
Wrapping<T>: Num,
[src]
T: Unsigned,
Wrapping<T>: Num,
Auto Trait Implementations
impl<T> RefUnwindSafe for Wrapping<T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
impl<T> Send for Wrapping<T> where
T: Send,
T: Send,
impl<T> Sync for Wrapping<T> where
T: Sync,
T: Sync,
impl<T> Unpin for Wrapping<T> where
T: Unpin,
T: Unpin,
impl<T> UnwindSafe for Wrapping<T> where
T: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]pub fn borrow_mut(&mut self) -> &mut T
[src]
pub fn borrow_mut(&mut self) -> &mut T
[src]Mutably borrows from an owned value. Read more
impl<T> Downcast for T where
T: Any,
impl<T> Downcast for T where
T: Any,
pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>ⓘNotable traits for Box<R, Global>
impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>ⓘNotable traits for Box<R, Global>
impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
Convert Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
. Read more
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
Convert Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
. Read more
pub fn as_any(&self) -> &(dyn Any + 'static)
pub fn as_any(&self) -> &(dyn Any + 'static)
Convert &Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s. Read more
pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s. Read more
impl<A> DynCastExt for A
impl<A> DynCastExt for A
pub fn dyn_cast<T>(
self
) -> Result<<A as DynCastExtHelper<T>>::Target, <A as DynCastExtHelper<T>>::Source> where
T: ?Sized,
A: DynCastExtHelper<T>,
pub fn dyn_cast<T>(
self
) -> Result<<A as DynCastExtHelper<T>>::Target, <A as DynCastExtHelper<T>>::Source> where
T: ?Sized,
A: DynCastExtHelper<T>,
Use this to cast from one trait object type to another. Read more
pub fn dyn_upcast<T>(self) -> <A as DynCastExtAdvHelper<T, T>>::Target where
T: ?Sized,
A: DynCastExtAdvHelper<T, T, Source = <A as DynCastExtAdvHelper<T, T>>::Target>,
pub fn dyn_upcast<T>(self) -> <A as DynCastExtAdvHelper<T, T>>::Target where
T: ?Sized,
A: DynCastExtAdvHelper<T, T, Source = <A as DynCastExtAdvHelper<T, T>>::Target>,
Use this to upcast a trait to one of its supertraits. Read more
pub fn dyn_cast_adv<F, T>(
self
) -> Result<<A as DynCastExtAdvHelper<F, T>>::Target, <A as DynCastExtAdvHelper<F, T>>::Source> where
T: ?Sized,
A: DynCastExtAdvHelper<F, T>,
F: ?Sized,
pub fn dyn_cast_adv<F, T>(
self
) -> Result<<A as DynCastExtAdvHelper<F, T>>::Target, <A as DynCastExtAdvHelper<F, T>>::Source> where
T: ?Sized,
A: DynCastExtAdvHelper<F, T>,
F: ?Sized,
pub fn dyn_cast_with_config<C>(
self
) -> Result<<A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Target, <A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Source> where
C: DynCastConfig,
A: DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>,
pub fn dyn_cast_with_config<C>(
self
) -> Result<<A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Target, <A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Source> where
C: DynCastConfig,
A: DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>,
Use this to cast from one trait object type to another. With this method the type parameter is a config type that uniquely specifies which cast should be preformed. Read more
impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized,
[src]
impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized,
[src]pub fn equivalent(&self, key: &K) -> bool
[src]
pub fn equivalent(&self, key: &K) -> bool
[src]Compare self to key
and return true
if they are equal.
impl<T> Instrument for T
[src]
impl<T> Instrument for T
[src]fn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
[src]
fn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
[src]Instruments this type with the provided Span
, returning an
Instrumented
wrapper. Read more
fn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
[src]
fn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
[src]impl<T> Serialize for T where
T: Serialize + ?Sized,
[src]
impl<T> Serialize for T where
T: Serialize + ?Sized,
[src]pub fn erased_serialize(
&self,
serializer: &mut dyn Serializer
) -> Result<Ok, Error>
[src]
&self,
serializer: &mut dyn Serializer
) -> Result<Ok, Error>
impl<T> ToOwned for T where
T: Clone,
[src]
impl<T> ToOwned for T where
T: Clone,
[src]type Owned = T
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn to_owned(&self) -> T
[src]Creates owned data from borrowed data, usually by cloning. Read more
pub fn clone_into(&self, target: &mut T)
[src]
pub fn clone_into(&self, target: &mut T)
[src]🔬 This is a nightly-only experimental API. (toowned_clone_into
)
recently added
Uses borrowed data to replace owned data, usually by cloning. Read more
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
pub fn vzip(self) -> V
impl<T> DeserializeOwned for T where
T: for<'de> Deserialize<'de>,
[src]
T: for<'de> Deserialize<'de>,
impl<T> NumAssign for T where
T: Num + NumAssignOps<T>,
[src]
T: Num + NumAssignOps<T>,
impl<T, Rhs> NumAssignOps<Rhs> for T where
T: AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>,
[src]
T: AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>,
impl<T> NumAssignRef for T where
T: NumAssign + for<'r> NumAssignOps<&'r T>,
[src]
T: NumAssign + for<'r> NumAssignOps<&'r T>,
impl<T, Rhs, Output> NumOps<Rhs, Output> for T where
T: Sub<Rhs, Output = Output> + Mul<Rhs, Output = Output> + Div<Rhs, Output = Output> + Add<Rhs, Output = Output> + Rem<Rhs, Output = Output>,
[src]
T: Sub<Rhs, Output = Output> + Mul<Rhs, Output = Output> + Div<Rhs, Output = Output> + Add<Rhs, Output = Output> + Rem<Rhs, Output = Output>,
impl<T> NumRef for T where
T: Num + for<'r> NumOps<&'r T, T>,
[src]
T: Num + for<'r> NumOps<&'r T, T>,
impl<T, Base> RefNum<Base> for T where
T: NumOps<Base, Base> + for<'r> NumOps<&'r Base, Base>,
[src]
T: NumOps<Base, Base> + for<'r> NumOps<&'r Base, Base>,
impl<T> RuleType for T where
T: Copy + Debug + Eq + Hash + Ord,
[src]
T: Copy + Debug + Eq + Hash + Ord,