Struct std::num::Wrapping

1.0.0 · source ·
#[repr(transparent)]
pub struct Wrapping<T>(pub T);
Expand description

T 上提供有意包装的算法。

u32 值上的 + 之类的操作旨在永不溢出,并且在某些调试配置中,检测到溢出并导致 panic。 尽管大多数算术都属于此类,但是某些代码明确期望并依赖于模块化算术 (例如,哈希)。

可以通过诸如 wrapping_add 之类的方法或通过 Wrapping<T> 类型来实现包装算术,该方法表示对底层值的所有标准算术运算都旨在具有包装语义。

可以通过 Wrapping 元组的 .0 索引检索底层值。

Examples

use std::num::Wrapping;

let zero = Wrapping(0u32);
let one = Wrapping(1u32);

assert_eq!(u32::MAX, (zero - one).0);
Run

Layout

Wrapping<T> 保证与 T 具有相同的布局和 ABI。

Tuple Fields§

§0: T

Implementations§

source§

impl Wrapping<usize>

source

pub const MIN: Wrapping<usize> = Self(usize::MIN)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最小值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<usize>>::MIN, Wrapping(usize::MIN));
Run
source

pub const MAX: Wrapping<usize> = Self(usize::MAX)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最大值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<usize>>::MAX, Wrapping(usize::MAX));
Run
source

pub const BITS: u32 = 64u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

以位为单位返回此整数类型的大小。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<usize>>::BITS, usize::BITS);
Run
source

pub const fn count_ones(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的位数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b01001100usize);

assert_eq!(n.count_ones(), 3);
Run
source

pub const fn count_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(!0usize).count_zeros(), 0);
Run
source

pub const fn trailing_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b0101000usize);

assert_eq!(n.trailing_zeros(), 3);
Run
source

pub const fn rotate_left(self, n: u32) -> Wrapping<usize>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位左移指定的量 n,将截断的位包装到结果整数的末尾。

请注意,此操作与 << 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn rotate_right(self, n: u32) -> Wrapping<usize>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位右移指定的量 n,将截断的位包装到结果整数的开头。

请注意,此操作与 >> 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn swap_bytes(self) -> Wrapping<usize>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

反转整数的字节顺序。

Examples

基本用法:

#![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));
Run
1.37.0 (const: 1.37.0) · source

pub const fn reverse_bits(self) -> Wrapping<usize>

反转整数的位模式。

Examples

请注意,此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16

基本用法:

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));
Run
source

pub const fn from_be(x: Wrapping<usize>) -> Wrapping<usize>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从大端字节序转换为目标的字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn from_le(x: Wrapping<usize>) -> Wrapping<usize>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从小端字节序转换为目标的字节序。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_be(self) -> Wrapping<usize>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为大字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_le(self) -> Wrapping<usize>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为 Little Endian。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub fn pow(self, exp: u32) -> Wrapping<usize>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

通过平方运算,将自己提升到 exp 的功效。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3usize).pow(4), Wrapping(81));
Run

太大的结果将被包装:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13));
assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
Run
source§

impl Wrapping<u8>

source

pub const MIN: Wrapping<u8> = Self(u8::MIN)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最小值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<u8>>::MIN, Wrapping(u8::MIN));
Run
source

pub const MAX: Wrapping<u8> = Self(u8::MAX)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最大值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<u8>>::MAX, Wrapping(u8::MAX));
Run
source

pub const BITS: u32 = 8u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

以位为单位返回此整数类型的大小。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<u8>>::BITS, u8::BITS);
Run
source

pub const fn count_ones(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的位数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b01001100u8);

assert_eq!(n.count_ones(), 3);
Run
source

pub const fn count_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(!0u8).count_zeros(), 0);
Run
source

pub const fn trailing_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b0101000u8);

assert_eq!(n.trailing_zeros(), 3);
Run
source

pub const fn rotate_left(self, n: u32) -> Wrapping<u8>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位左移指定的量 n,将截断的位包装到结果整数的末尾。

请注意,此操作与 << 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn rotate_right(self, n: u32) -> Wrapping<u8>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位右移指定的量 n,将截断的位包装到结果整数的开头。

请注意,此操作与 >> 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn swap_bytes(self) -> Wrapping<u8>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

反转整数的字节顺序。

Examples

基本用法:

#![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));
Run
1.37.0 (const: 1.37.0) · source

pub const fn reverse_bits(self) -> Wrapping<u8>

反转整数的位模式。

Examples

请注意,此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16

基本用法:

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));
Run
source

pub const fn from_be(x: Wrapping<u8>) -> Wrapping<u8>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从大端字节序转换为目标的字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn from_le(x: Wrapping<u8>) -> Wrapping<u8>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从小端字节序转换为目标的字节序。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_be(self) -> Wrapping<u8>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为大字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_le(self) -> Wrapping<u8>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为 Little Endian。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub fn pow(self, exp: u32) -> Wrapping<u8>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

通过平方运算,将自己提升到 exp 的功效。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3u8).pow(4), Wrapping(81));
Run

太大的结果将被包装:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13));
assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
Run
source§

impl Wrapping<u16>

source

pub const MIN: Wrapping<u16> = Self(u16::MIN)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最小值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<u16>>::MIN, Wrapping(u16::MIN));
Run
source

pub const MAX: Wrapping<u16> = Self(u16::MAX)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最大值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<u16>>::MAX, Wrapping(u16::MAX));
Run
source

pub const BITS: u32 = 16u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

以位为单位返回此整数类型的大小。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<u16>>::BITS, u16::BITS);
Run
source

pub const fn count_ones(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的位数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b01001100u16);

assert_eq!(n.count_ones(), 3);
Run
source

pub const fn count_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(!0u16).count_zeros(), 0);
Run
source

pub const fn trailing_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b0101000u16);

assert_eq!(n.trailing_zeros(), 3);
Run
source

pub const fn rotate_left(self, n: u32) -> Wrapping<u16>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位左移指定的量 n,将截断的位包装到结果整数的末尾。

请注意,此操作与 << 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn rotate_right(self, n: u32) -> Wrapping<u16>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位右移指定的量 n,将截断的位包装到结果整数的开头。

请注意,此操作与 >> 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn swap_bytes(self) -> Wrapping<u16>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

反转整数的字节顺序。

Examples

基本用法:

#![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));
Run
1.37.0 (const: 1.37.0) · source

pub const fn reverse_bits(self) -> Wrapping<u16>

反转整数的位模式。

Examples

请注意,此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16

基本用法:

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));
Run
source

pub const fn from_be(x: Wrapping<u16>) -> Wrapping<u16>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从大端字节序转换为目标的字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn from_le(x: Wrapping<u16>) -> Wrapping<u16>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从小端字节序转换为目标的字节序。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_be(self) -> Wrapping<u16>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为大字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_le(self) -> Wrapping<u16>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为 Little Endian。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub fn pow(self, exp: u32) -> Wrapping<u16>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

通过平方运算,将自己提升到 exp 的功效。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3u16).pow(4), Wrapping(81));
Run

太大的结果将被包装:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13));
assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
Run
source§

impl Wrapping<u32>

source

pub const MIN: Wrapping<u32> = Self(u32::MIN)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最小值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<u32>>::MIN, Wrapping(u32::MIN));
Run
source

pub const MAX: Wrapping<u32> = Self(u32::MAX)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最大值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<u32>>::MAX, Wrapping(u32::MAX));
Run
source

pub const BITS: u32 = 32u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

以位为单位返回此整数类型的大小。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<u32>>::BITS, u32::BITS);
Run
source

pub const fn count_ones(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的位数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b01001100u32);

assert_eq!(n.count_ones(), 3);
Run
source

pub const fn count_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(!0u32).count_zeros(), 0);
Run
source

pub const fn trailing_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b0101000u32);

assert_eq!(n.trailing_zeros(), 3);
Run
source

pub const fn rotate_left(self, n: u32) -> Wrapping<u32>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位左移指定的量 n,将截断的位包装到结果整数的末尾。

请注意,此操作与 << 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn rotate_right(self, n: u32) -> Wrapping<u32>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位右移指定的量 n,将截断的位包装到结果整数的开头。

请注意,此操作与 >> 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn swap_bytes(self) -> Wrapping<u32>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

反转整数的字节顺序。

Examples

基本用法:

#![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));
Run
1.37.0 (const: 1.37.0) · source

pub const fn reverse_bits(self) -> Wrapping<u32>

反转整数的位模式。

Examples

请注意,此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16

基本用法:

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));
Run
source

pub const fn from_be(x: Wrapping<u32>) -> Wrapping<u32>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从大端字节序转换为目标的字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn from_le(x: Wrapping<u32>) -> Wrapping<u32>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从小端字节序转换为目标的字节序。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_be(self) -> Wrapping<u32>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为大字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_le(self) -> Wrapping<u32>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为 Little Endian。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

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

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

通过平方运算,将自己提升到 exp 的功效。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3u32).pow(4), Wrapping(81));
Run

太大的结果将被包装:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13));
assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
Run
source§

impl Wrapping<u64>

source

pub const MIN: Wrapping<u64> = Self(u64::MIN)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最小值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<u64>>::MIN, Wrapping(u64::MIN));
Run
source

pub const MAX: Wrapping<u64> = Self(u64::MAX)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最大值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<u64>>::MAX, Wrapping(u64::MAX));
Run
source

pub const BITS: u32 = 64u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

以位为单位返回此整数类型的大小。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<u64>>::BITS, u64::BITS);
Run
source

pub const fn count_ones(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的位数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b01001100u64);

assert_eq!(n.count_ones(), 3);
Run
source

pub const fn count_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(!0u64).count_zeros(), 0);
Run
source

pub const fn trailing_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b0101000u64);

assert_eq!(n.trailing_zeros(), 3);
Run
source

pub const fn rotate_left(self, n: u32) -> Wrapping<u64>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位左移指定的量 n,将截断的位包装到结果整数的末尾。

请注意,此操作与 << 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn rotate_right(self, n: u32) -> Wrapping<u64>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位右移指定的量 n,将截断的位包装到结果整数的开头。

请注意,此操作与 >> 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn swap_bytes(self) -> Wrapping<u64>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

反转整数的字节顺序。

Examples

基本用法:

#![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));
Run
1.37.0 (const: 1.37.0) · source

pub const fn reverse_bits(self) -> Wrapping<u64>

反转整数的位模式。

Examples

请注意,此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16

基本用法:

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));
Run
source

pub const fn from_be(x: Wrapping<u64>) -> Wrapping<u64>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从大端字节序转换为目标的字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn from_le(x: Wrapping<u64>) -> Wrapping<u64>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从小端字节序转换为目标的字节序。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_be(self) -> Wrapping<u64>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为大字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_le(self) -> Wrapping<u64>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为 Little Endian。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub fn pow(self, exp: u32) -> Wrapping<u64>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

通过平方运算,将自己提升到 exp 的功效。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3u64).pow(4), Wrapping(81));
Run

太大的结果将被包装:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13));
assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
Run
source§

impl Wrapping<u128>

source

pub const MIN: Wrapping<u128> = Self(u128::MIN)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最小值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<u128>>::MIN, Wrapping(u128::MIN));
Run
source

pub const MAX: Wrapping<u128> = Self(u128::MAX)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最大值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<u128>>::MAX, Wrapping(u128::MAX));
Run
source

pub const BITS: u32 = 128u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

以位为单位返回此整数类型的大小。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<u128>>::BITS, u128::BITS);
Run
source

pub const fn count_ones(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的位数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b01001100u128);

assert_eq!(n.count_ones(), 3);
Run
source

pub const fn count_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(!0u128).count_zeros(), 0);
Run
source

pub const fn trailing_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b0101000u128);

assert_eq!(n.trailing_zeros(), 3);
Run
source

pub const fn rotate_left(self, n: u32) -> Wrapping<u128>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位左移指定的量 n,将截断的位包装到结果整数的末尾。

请注意,此操作与 << 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn rotate_right(self, n: u32) -> Wrapping<u128>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位右移指定的量 n,将截断的位包装到结果整数的开头。

请注意,此操作与 >> 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn swap_bytes(self) -> Wrapping<u128>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

反转整数的字节顺序。

Examples

基本用法:

#![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));
Run
1.37.0 (const: 1.37.0) · source

pub const fn reverse_bits(self) -> Wrapping<u128>

反转整数的位模式。

Examples

请注意,此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16

基本用法:

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));
Run
source

pub const fn from_be(x: Wrapping<u128>) -> Wrapping<u128>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从大端字节序转换为目标的字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn from_le(x: Wrapping<u128>) -> Wrapping<u128>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从小端字节序转换为目标的字节序。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_be(self) -> Wrapping<u128>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为大字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_le(self) -> Wrapping<u128>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为 Little Endian。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub fn pow(self, exp: u32) -> Wrapping<u128>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

通过平方运算,将自己提升到 exp 的功效。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3u128).pow(4), Wrapping(81));
Run

太大的结果将被包装:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13));
assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
Run
source§

impl Wrapping<isize>

source

pub const MIN: Wrapping<isize> = Self(isize::MIN)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最小值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<isize>>::MIN, Wrapping(isize::MIN));
Run
source

pub const MAX: Wrapping<isize> = Self(isize::MAX)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最大值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<isize>>::MAX, Wrapping(isize::MAX));
Run
source

pub const BITS: u32 = 64u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

以位为单位返回此整数类型的大小。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<isize>>::BITS, isize::BITS);
Run
source

pub const fn count_ones(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的位数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b01001100isize);

assert_eq!(n.count_ones(), 3);
Run
source

pub const fn count_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(!0isize).count_zeros(), 0);
Run
source

pub const fn trailing_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b0101000isize);

assert_eq!(n.trailing_zeros(), 3);
Run
source

pub const fn rotate_left(self, n: u32) -> Wrapping<isize>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位左移指定的量 n,将截断的位包装到结果整数的末尾。

请注意,此操作与 << 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn rotate_right(self, n: u32) -> Wrapping<isize>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位右移指定的量 n,将截断的位包装到结果整数的开头。

请注意,此操作与 >> 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn swap_bytes(self) -> Wrapping<isize>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

反转整数的字节顺序。

Examples

基本用法:

#![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));
Run
1.37.0 (const: 1.37.0) · source

pub const fn reverse_bits(self) -> Wrapping<isize>

反转整数的位模式。

Examples

请注意,此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16

基本用法:

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));
Run
source

pub const fn from_be(x: Wrapping<isize>) -> Wrapping<isize>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从大端字节序转换为目标的字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn from_le(x: Wrapping<isize>) -> Wrapping<isize>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从小端字节序转换为目标的字节序。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_be(self) -> Wrapping<isize>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为大字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_le(self) -> Wrapping<isize>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为 Little Endian。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub fn pow(self, exp: u32) -> Wrapping<isize>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

通过平方运算,将自己提升到 exp 的功效。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3isize).pow(4), Wrapping(81));
Run

太大的结果将被包装:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13));
assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
Run
source§

impl Wrapping<i8>

source

pub const MIN: Wrapping<i8> = Self(i8::MIN)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最小值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<i8>>::MIN, Wrapping(i8::MIN));
Run
source

pub const MAX: Wrapping<i8> = Self(i8::MAX)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最大值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<i8>>::MAX, Wrapping(i8::MAX));
Run
source

pub const BITS: u32 = 8u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

以位为单位返回此整数类型的大小。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<i8>>::BITS, i8::BITS);
Run
source

pub const fn count_ones(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的位数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b01001100i8);

assert_eq!(n.count_ones(), 3);
Run
source

pub const fn count_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(!0i8).count_zeros(), 0);
Run
source

pub const fn trailing_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b0101000i8);

assert_eq!(n.trailing_zeros(), 3);
Run
source

pub const fn rotate_left(self, n: u32) -> Wrapping<i8>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位左移指定的量 n,将截断的位包装到结果整数的末尾。

请注意,此操作与 << 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn rotate_right(self, n: u32) -> Wrapping<i8>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位右移指定的量 n,将截断的位包装到结果整数的开头。

请注意,此操作与 >> 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn swap_bytes(self) -> Wrapping<i8>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

反转整数的字节顺序。

Examples

基本用法:

#![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));
Run
1.37.0 (const: 1.37.0) · source

pub const fn reverse_bits(self) -> Wrapping<i8>

反转整数的位模式。

Examples

请注意,此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16

基本用法:

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));
Run
source

pub const fn from_be(x: Wrapping<i8>) -> Wrapping<i8>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从大端字节序转换为目标的字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn from_le(x: Wrapping<i8>) -> Wrapping<i8>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从小端字节序转换为目标的字节序。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_be(self) -> Wrapping<i8>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为大字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_le(self) -> Wrapping<i8>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为 Little Endian。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub fn pow(self, exp: u32) -> Wrapping<i8>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

通过平方运算,将自己提升到 exp 的功效。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3i8).pow(4), Wrapping(81));
Run

太大的结果将被包装:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13));
assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
Run
source§

impl Wrapping<i16>

source

pub const MIN: Wrapping<i16> = Self(i16::MIN)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最小值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<i16>>::MIN, Wrapping(i16::MIN));
Run
source

pub const MAX: Wrapping<i16> = Self(i16::MAX)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最大值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<i16>>::MAX, Wrapping(i16::MAX));
Run
source

pub const BITS: u32 = 16u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

以位为单位返回此整数类型的大小。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<i16>>::BITS, i16::BITS);
Run
source

pub const fn count_ones(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的位数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b01001100i16);

assert_eq!(n.count_ones(), 3);
Run
source

pub const fn count_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(!0i16).count_zeros(), 0);
Run
source

pub const fn trailing_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b0101000i16);

assert_eq!(n.trailing_zeros(), 3);
Run
source

pub const fn rotate_left(self, n: u32) -> Wrapping<i16>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位左移指定的量 n,将截断的位包装到结果整数的末尾。

请注意,此操作与 << 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn rotate_right(self, n: u32) -> Wrapping<i16>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位右移指定的量 n,将截断的位包装到结果整数的开头。

请注意,此操作与 >> 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn swap_bytes(self) -> Wrapping<i16>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

反转整数的字节顺序。

Examples

基本用法:

#![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));
Run
1.37.0 (const: 1.37.0) · source

pub const fn reverse_bits(self) -> Wrapping<i16>

反转整数的位模式。

Examples

请注意,此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16

基本用法:

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));
Run
source

pub const fn from_be(x: Wrapping<i16>) -> Wrapping<i16>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从大端字节序转换为目标的字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn from_le(x: Wrapping<i16>) -> Wrapping<i16>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从小端字节序转换为目标的字节序。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_be(self) -> Wrapping<i16>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为大字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_le(self) -> Wrapping<i16>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为 Little Endian。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub fn pow(self, exp: u32) -> Wrapping<i16>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

通过平方运算,将自己提升到 exp 的功效。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3i16).pow(4), Wrapping(81));
Run

太大的结果将被包装:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13));
assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
Run
source§

impl Wrapping<i32>

source

pub const MIN: Wrapping<i32> = Self(i32::MIN)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最小值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<i32>>::MIN, Wrapping(i32::MIN));
Run
source

pub const MAX: Wrapping<i32> = Self(i32::MAX)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最大值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<i32>>::MAX, Wrapping(i32::MAX));
Run
source

pub const BITS: u32 = 32u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

以位为单位返回此整数类型的大小。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<i32>>::BITS, i32::BITS);
Run
source

pub const fn count_ones(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的位数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b01001100i32);

assert_eq!(n.count_ones(), 3);
Run
source

pub const fn count_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(!0i32).count_zeros(), 0);
Run
source

pub const fn trailing_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b0101000i32);

assert_eq!(n.trailing_zeros(), 3);
Run
source

pub const fn rotate_left(self, n: u32) -> Wrapping<i32>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位左移指定的量 n,将截断的位包装到结果整数的末尾。

请注意,此操作与 << 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn rotate_right(self, n: u32) -> Wrapping<i32>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位右移指定的量 n,将截断的位包装到结果整数的开头。

请注意,此操作与 >> 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn swap_bytes(self) -> Wrapping<i32>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

反转整数的字节顺序。

Examples

基本用法:

#![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));
Run
1.37.0 (const: 1.37.0) · source

pub const fn reverse_bits(self) -> Wrapping<i32>

反转整数的位模式。

Examples

请注意,此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16

基本用法:

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));
Run
source

pub const fn from_be(x: Wrapping<i32>) -> Wrapping<i32>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从大端字节序转换为目标的字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn from_le(x: Wrapping<i32>) -> Wrapping<i32>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从小端字节序转换为目标的字节序。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_be(self) -> Wrapping<i32>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为大字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_le(self) -> Wrapping<i32>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为 Little Endian。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub fn pow(self, exp: u32) -> Wrapping<i32>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

通过平方运算,将自己提升到 exp 的功效。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3i32).pow(4), Wrapping(81));
Run

太大的结果将被包装:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13));
assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
Run
source§

impl Wrapping<i64>

source

pub const MIN: Wrapping<i64> = Self(i64::MIN)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最小值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<i64>>::MIN, Wrapping(i64::MIN));
Run
source

pub const MAX: Wrapping<i64> = Self(i64::MAX)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最大值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<i64>>::MAX, Wrapping(i64::MAX));
Run
source

pub const BITS: u32 = 64u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

以位为单位返回此整数类型的大小。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<i64>>::BITS, i64::BITS);
Run
source

pub const fn count_ones(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的位数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b01001100i64);

assert_eq!(n.count_ones(), 3);
Run
source

pub const fn count_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(!0i64).count_zeros(), 0);
Run
source

pub const fn trailing_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b0101000i64);

assert_eq!(n.trailing_zeros(), 3);
Run
source

pub const fn rotate_left(self, n: u32) -> Wrapping<i64>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位左移指定的量 n,将截断的位包装到结果整数的末尾。

请注意,此操作与 << 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn rotate_right(self, n: u32) -> Wrapping<i64>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位右移指定的量 n,将截断的位包装到结果整数的开头。

请注意,此操作与 >> 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn swap_bytes(self) -> Wrapping<i64>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

反转整数的字节顺序。

Examples

基本用法:

#![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));
Run
1.37.0 (const: 1.37.0) · source

pub const fn reverse_bits(self) -> Wrapping<i64>

反转整数的位模式。

Examples

请注意,此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16

基本用法:

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));
Run
source

pub const fn from_be(x: Wrapping<i64>) -> Wrapping<i64>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从大端字节序转换为目标的字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn from_le(x: Wrapping<i64>) -> Wrapping<i64>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从小端字节序转换为目标的字节序。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_be(self) -> Wrapping<i64>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为大字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_le(self) -> Wrapping<i64>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为 Little Endian。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub fn pow(self, exp: u32) -> Wrapping<i64>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

通过平方运算,将自己提升到 exp 的功效。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3i64).pow(4), Wrapping(81));
Run

太大的结果将被包装:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13));
assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
Run
source§

impl Wrapping<i128>

source

pub const MIN: Wrapping<i128> = Self(i128::MIN)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最小值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<i128>>::MIN, Wrapping(i128::MIN));
Run
source

pub const MAX: Wrapping<i128> = Self(i128::MAX)

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回此整数类型可以表示的最大值。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<i128>>::MAX, Wrapping(i128::MAX));
Run
source

pub const BITS: u32 = 128u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

以位为单位返回此整数类型的大小。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(<Wrapping<i128>>::BITS, i128::BITS);
Run
source

pub const fn count_ones(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的位数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b01001100i128);

assert_eq!(n.count_ones(), 3);
Run
source

pub const fn count_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(!0i128).count_zeros(), 0);
Run
source

pub const fn trailing_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(0b0101000i128);

assert_eq!(n.trailing_zeros(), 3);
Run
source

pub const fn rotate_left(self, n: u32) -> Wrapping<i128>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位左移指定的量 n,将截断的位包装到结果整数的末尾。

请注意,此操作与 << 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn rotate_right(self, n: u32) -> Wrapping<i128>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将位右移指定的量 n,将截断的位包装到结果整数的开头。

请注意,此操作与 >> 移位运算符不同!

Examples

基本用法:

#![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);
Run
source

pub const fn swap_bytes(self) -> Wrapping<i128>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

反转整数的字节顺序。

Examples

基本用法:

#![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));
Run
1.37.0 (const: 1.37.0) · source

pub const fn reverse_bits(self) -> Wrapping<i128>

反转整数的位模式。

Examples

请注意,此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16

基本用法:

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));
Run
source

pub const fn from_be(x: Wrapping<i128>) -> Wrapping<i128>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从大端字节序转换为目标的字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn from_le(x: Wrapping<i128>) -> Wrapping<i128>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

将整数从小端字节序转换为目标的字节序。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_be(self) -> Wrapping<i128>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为大字节序。

在大端节序序上,这是个禁忌。 在小端字节序上,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub const fn to_le(self) -> Wrapping<i128>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

self 从目标的字节序转换为 Little Endian。

在小端字节序上,这是个禁忌。 在大字节序中,字节被交换。

Examples

基本用法:

#![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())
}
Run
source

pub fn pow(self, exp: u32) -> Wrapping<i128>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

通过平方运算,将自己提升到 exp 的功效。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3i128).pow(4), Wrapping(81));
Run

太大的结果将被包装:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13));
assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
Run
source§

impl Wrapping<isize>

source

pub const fn leading_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(isize::MAX) >> 2;

assert_eq!(n.leading_zeros(), 3);
Run
source

pub fn abs(self) -> Wrapping<isize>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

计算 self 的绝对值,环绕在类型的边界处。

可能发生这种换行的唯一情况是,当一个类型取负的最小值的绝对值时,该正值太大而无法在类型中表示。 在这种情况下,此函数将返回 MIN 本身。

Examples

基本用法:

#![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);
Run
source

pub fn signum(self) -> Wrapping<isize>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回一个表示 self 的符号的数字。

  • 0 如果数字为零
  • 1 如果数字是正数
  • -1 如果数字是负数
Examples

基本用法:

#![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));
Run
source

pub const fn is_positive(self) -> bool

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

如果 self 为正数,则返回 true; 如果数字为零或负数,则返回 false

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert!(Wrapping(10isize).is_positive());
assert!(!Wrapping(-10isize).is_positive());
Run
source

pub const fn is_negative(self) -> bool

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

如果 self 为负,则返回 true; 如果数字为零或正,则返回 false

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert!(Wrapping(-10isize).is_negative());
assert!(!Wrapping(10isize).is_negative());
Run
source§

impl Wrapping<i8>

source

pub const fn leading_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(i8::MAX) >> 2;

assert_eq!(n.leading_zeros(), 3);
Run
source

pub fn abs(self) -> Wrapping<i8>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

计算 self 的绝对值,环绕在类型的边界处。

可能发生这种换行的唯一情况是,当一个类型取负的最小值的绝对值时,该正值太大而无法在类型中表示。 在这种情况下,此函数将返回 MIN 本身。

Examples

基本用法:

#![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);
Run
source

pub fn signum(self) -> Wrapping<i8>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回一个表示 self 的符号的数字。

  • 0 如果数字为零
  • 1 如果数字是正数
  • -1 如果数字是负数
Examples

基本用法:

#![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));
Run
source

pub const fn is_positive(self) -> bool

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

如果 self 为正数,则返回 true; 如果数字为零或负数,则返回 false

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert!(Wrapping(10i8).is_positive());
assert!(!Wrapping(-10i8).is_positive());
Run
source

pub const fn is_negative(self) -> bool

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

如果 self 为负,则返回 true; 如果数字为零或正,则返回 false

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert!(Wrapping(-10i8).is_negative());
assert!(!Wrapping(10i8).is_negative());
Run
source§

impl Wrapping<i16>

source

pub const fn leading_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(i16::MAX) >> 2;

assert_eq!(n.leading_zeros(), 3);
Run
source

pub fn abs(self) -> Wrapping<i16>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

计算 self 的绝对值,环绕在类型的边界处。

可能发生这种换行的唯一情况是,当一个类型取负的最小值的绝对值时,该正值太大而无法在类型中表示。 在这种情况下,此函数将返回 MIN 本身。

Examples

基本用法:

#![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);
Run
source

pub fn signum(self) -> Wrapping<i16>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回一个表示 self 的符号的数字。

  • 0 如果数字为零
  • 1 如果数字是正数
  • -1 如果数字是负数
Examples

基本用法:

#![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));
Run
source

pub const fn is_positive(self) -> bool

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

如果 self 为正数,则返回 true; 如果数字为零或负数,则返回 false

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert!(Wrapping(10i16).is_positive());
assert!(!Wrapping(-10i16).is_positive());
Run
source

pub const fn is_negative(self) -> bool

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

如果 self 为负,则返回 true; 如果数字为零或正,则返回 false

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert!(Wrapping(-10i16).is_negative());
assert!(!Wrapping(10i16).is_negative());
Run
source§

impl Wrapping<i32>

source

pub const fn leading_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(i32::MAX) >> 2;

assert_eq!(n.leading_zeros(), 3);
Run
source

pub fn abs(self) -> Wrapping<i32>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

计算 self 的绝对值,环绕在类型的边界处。

可能发生这种换行的唯一情况是,当一个类型取负的最小值的绝对值时,该正值太大而无法在类型中表示。 在这种情况下,此函数将返回 MIN 本身。

Examples

基本用法:

#![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);
Run
source

pub fn signum(self) -> Wrapping<i32>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回一个表示 self 的符号的数字。

  • 0 如果数字为零
  • 1 如果数字是正数
  • -1 如果数字是负数
Examples

基本用法:

#![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));
Run
source

pub const fn is_positive(self) -> bool

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

如果 self 为正数,则返回 true; 如果数字为零或负数,则返回 false

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert!(Wrapping(10i32).is_positive());
assert!(!Wrapping(-10i32).is_positive());
Run
source

pub const fn is_negative(self) -> bool

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

如果 self 为负,则返回 true; 如果数字为零或正,则返回 false

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert!(Wrapping(-10i32).is_negative());
assert!(!Wrapping(10i32).is_negative());
Run
source§

impl Wrapping<i64>

source

pub const fn leading_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(i64::MAX) >> 2;

assert_eq!(n.leading_zeros(), 3);
Run
source

pub fn abs(self) -> Wrapping<i64>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

计算 self 的绝对值,环绕在类型的边界处。

可能发生这种换行的唯一情况是,当一个类型取负的最小值的绝对值时,该正值太大而无法在类型中表示。 在这种情况下,此函数将返回 MIN 本身。

Examples

基本用法:

#![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);
Run
source

pub fn signum(self) -> Wrapping<i64>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回一个表示 self 的符号的数字。

  • 0 如果数字为零
  • 1 如果数字是正数
  • -1 如果数字是负数
Examples

基本用法:

#![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));
Run
source

pub const fn is_positive(self) -> bool

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

如果 self 为正数,则返回 true; 如果数字为零或负数,则返回 false

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert!(Wrapping(10i64).is_positive());
assert!(!Wrapping(-10i64).is_positive());
Run
source

pub const fn is_negative(self) -> bool

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

如果 self 为负,则返回 true; 如果数字为零或正,则返回 false

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert!(Wrapping(-10i64).is_negative());
assert!(!Wrapping(10i64).is_negative());
Run
source§

impl Wrapping<i128>

source

pub const fn leading_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(i128::MAX) >> 2;

assert_eq!(n.leading_zeros(), 3);
Run
source

pub fn abs(self) -> Wrapping<i128>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

计算 self 的绝对值,环绕在类型的边界处。

可能发生这种换行的唯一情况是,当一个类型取负的最小值的绝对值时,该正值太大而无法在类型中表示。 在这种情况下,此函数将返回 MIN 本身。

Examples

基本用法:

#![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);
Run
source

pub fn signum(self) -> Wrapping<i128>

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回一个表示 self 的符号的数字。

  • 0 如果数字为零
  • 1 如果数字是正数
  • -1 如果数字是负数
Examples

基本用法:

#![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));
Run
source

pub const fn is_positive(self) -> bool

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

如果 self 为正数,则返回 true; 如果数字为零或负数,则返回 false

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert!(Wrapping(10i128).is_positive());
assert!(!Wrapping(-10i128).is_positive());
Run
source

pub const fn is_negative(self) -> bool

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

如果 self 为负,则返回 true; 如果数字为零或正,则返回 false

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert!(Wrapping(-10i128).is_negative());
assert!(!Wrapping(10i128).is_negative());
Run
source§

impl Wrapping<usize>

source

pub const fn leading_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(usize::MAX) >> 2;

assert_eq!(n.leading_zeros(), 2);
Run
source

pub fn is_power_of_two(self) -> bool

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

当且仅当某些 kself == 2^k 时,才返回 true

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert!(Wrapping(16usize).is_power_of_two());
assert!(!Wrapping(10usize).is_power_of_two());
Run
source

pub fn next_power_of_two(self) -> Wrapping<usize>

🔬This is a nightly-only experimental API. (wrapping_next_power_of_two #32463)

返回大于或等于 self 的 2 的最小幂。

当返回值溢出时 (即,uN 类型为 self > (1 << (N-1))),溢出到 2^N = 0

Examples

基本用法:

#![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));
Run
source§

impl Wrapping<u8>

source

pub const fn leading_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(u8::MAX) >> 2;

assert_eq!(n.leading_zeros(), 2);
Run
source

pub fn is_power_of_two(self) -> bool

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

当且仅当某些 kself == 2^k 时,才返回 true

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert!(Wrapping(16u8).is_power_of_two());
assert!(!Wrapping(10u8).is_power_of_two());
Run
source

pub fn next_power_of_two(self) -> Wrapping<u8>

🔬This is a nightly-only experimental API. (wrapping_next_power_of_two #32463)

返回大于或等于 self 的 2 的最小幂。

当返回值溢出时 (即,uN 类型为 self > (1 << (N-1))),溢出到 2^N = 0

Examples

基本用法:

#![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));
Run
source§

impl Wrapping<u16>

source

pub const fn leading_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(u16::MAX) >> 2;

assert_eq!(n.leading_zeros(), 2);
Run
source

pub fn is_power_of_two(self) -> bool

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

当且仅当某些 kself == 2^k 时,才返回 true

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert!(Wrapping(16u16).is_power_of_two());
assert!(!Wrapping(10u16).is_power_of_two());
Run
source

pub fn next_power_of_two(self) -> Wrapping<u16>

🔬This is a nightly-only experimental API. (wrapping_next_power_of_two #32463)

返回大于或等于 self 的 2 的最小幂。

当返回值溢出时 (即,uN 类型为 self > (1 << (N-1))),溢出到 2^N = 0

Examples

基本用法:

#![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));
Run
source§

impl Wrapping<u32>

source

pub const fn leading_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(u32::MAX) >> 2;

assert_eq!(n.leading_zeros(), 2);
Run
source

pub fn is_power_of_two(self) -> bool

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

当且仅当某些 kself == 2^k 时,才返回 true

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert!(Wrapping(16u32).is_power_of_two());
assert!(!Wrapping(10u32).is_power_of_two());
Run
source

pub fn next_power_of_two(self) -> Wrapping<u32>

🔬This is a nightly-only experimental API. (wrapping_next_power_of_two #32463)

返回大于或等于 self 的 2 的最小幂。

当返回值溢出时 (即,uN 类型为 self > (1 << (N-1))),溢出到 2^N = 0

Examples

基本用法:

#![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));
Run
source§

impl Wrapping<u64>

source

pub const fn leading_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(u64::MAX) >> 2;

assert_eq!(n.leading_zeros(), 2);
Run
source

pub fn is_power_of_two(self) -> bool

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

当且仅当某些 kself == 2^k 时,才返回 true

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert!(Wrapping(16u64).is_power_of_two());
assert!(!Wrapping(10u64).is_power_of_two());
Run
source

pub fn next_power_of_two(self) -> Wrapping<u64>

🔬This is a nightly-only experimental API. (wrapping_next_power_of_two #32463)

返回大于或等于 self 的 2 的最小幂。

当返回值溢出时 (即,uN 类型为 self > (1 << (N-1))),溢出到 2^N = 0

Examples

基本用法:

#![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));
Run
source§

impl Wrapping<u128>

source

pub const fn leading_zeros(self) -> u32

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

let n = Wrapping(u128::MAX) >> 2;

assert_eq!(n.leading_zeros(), 2);
Run
source

pub fn is_power_of_two(self) -> bool

🔬This is a nightly-only experimental API. (wrapping_int_impl #32463)

当且仅当某些 kself == 2^k 时,才返回 true

Examples

基本用法:

#![feature(wrapping_int_impl)]
use std::num::Wrapping;

assert!(Wrapping(16u128).is_power_of_two());
assert!(!Wrapping(10u128).is_power_of_two());
Run
source

pub fn next_power_of_two(self) -> Wrapping<u128>

🔬This is a nightly-only experimental API. (wrapping_next_power_of_two #32463)

返回大于或等于 self 的 2 的最小幂。

当返回值溢出时 (即,uN 类型为 self > (1 << (N-1))),溢出到 2^N = 0

Examples

基本用法:

#![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));
Run

Trait Implementations§

1.14.0 · source§

impl Add<&Wrapping<i128>> for &Wrapping<i128>

§

type Output = <Wrapping<i128> as Add<Wrapping<i128>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<i128> ) -> <Wrapping<i128> as Add<Wrapping<i128>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<i128>> for Wrapping<i128>

§

type Output = <Wrapping<i128> as Add<Wrapping<i128>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<i128> ) -> <Wrapping<i128> as Add<Wrapping<i128>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<i16>> for &Wrapping<i16>

§

type Output = <Wrapping<i16> as Add<Wrapping<i16>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<i16> ) -> <Wrapping<i16> as Add<Wrapping<i16>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<i16>> for Wrapping<i16>

§

type Output = <Wrapping<i16> as Add<Wrapping<i16>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<i16> ) -> <Wrapping<i16> as Add<Wrapping<i16>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<i32>> for &Wrapping<i32>

§

type Output = <Wrapping<i32> as Add<Wrapping<i32>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<i32> ) -> <Wrapping<i32> as Add<Wrapping<i32>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<i32>> for Wrapping<i32>

§

type Output = <Wrapping<i32> as Add<Wrapping<i32>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<i32> ) -> <Wrapping<i32> as Add<Wrapping<i32>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<i64>> for &Wrapping<i64>

§

type Output = <Wrapping<i64> as Add<Wrapping<i64>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<i64> ) -> <Wrapping<i64> as Add<Wrapping<i64>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<i64>> for Wrapping<i64>

§

type Output = <Wrapping<i64> as Add<Wrapping<i64>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<i64> ) -> <Wrapping<i64> as Add<Wrapping<i64>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<i8>> for &Wrapping<i8>

§

type Output = <Wrapping<i8> as Add<Wrapping<i8>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<i8> ) -> <Wrapping<i8> as Add<Wrapping<i8>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<i8>> for Wrapping<i8>

§

type Output = <Wrapping<i8> as Add<Wrapping<i8>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<i8> ) -> <Wrapping<i8> as Add<Wrapping<i8>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<isize>> for &Wrapping<isize>

§

type Output = <Wrapping<isize> as Add<Wrapping<isize>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<isize> ) -> <Wrapping<isize> as Add<Wrapping<isize>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<isize>> for Wrapping<isize>

§

type Output = <Wrapping<isize> as Add<Wrapping<isize>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<isize> ) -> <Wrapping<isize> as Add<Wrapping<isize>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<u128>> for &Wrapping<u128>

§

type Output = <Wrapping<u128> as Add<Wrapping<u128>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<u128> ) -> <Wrapping<u128> as Add<Wrapping<u128>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<u128>> for Wrapping<u128>

§

type Output = <Wrapping<u128> as Add<Wrapping<u128>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<u128> ) -> <Wrapping<u128> as Add<Wrapping<u128>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<u16>> for &Wrapping<u16>

§

type Output = <Wrapping<u16> as Add<Wrapping<u16>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<u16> ) -> <Wrapping<u16> as Add<Wrapping<u16>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<u16>> for Wrapping<u16>

§

type Output = <Wrapping<u16> as Add<Wrapping<u16>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<u16> ) -> <Wrapping<u16> as Add<Wrapping<u16>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<u32>> for &Wrapping<u32>

§

type Output = <Wrapping<u32> as Add<Wrapping<u32>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<u32> ) -> <Wrapping<u32> as Add<Wrapping<u32>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<u32>> for Wrapping<u32>

§

type Output = <Wrapping<u32> as Add<Wrapping<u32>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<u32> ) -> <Wrapping<u32> as Add<Wrapping<u32>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<u64>> for &Wrapping<u64>

§

type Output = <Wrapping<u64> as Add<Wrapping<u64>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<u64> ) -> <Wrapping<u64> as Add<Wrapping<u64>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<u64>> for Wrapping<u64>

§

type Output = <Wrapping<u64> as Add<Wrapping<u64>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<u64> ) -> <Wrapping<u64> as Add<Wrapping<u64>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<u8>> for &Wrapping<u8>

§

type Output = <Wrapping<u8> as Add<Wrapping<u8>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<u8> ) -> <Wrapping<u8> as Add<Wrapping<u8>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<u8>> for Wrapping<u8>

§

type Output = <Wrapping<u8> as Add<Wrapping<u8>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<u8> ) -> <Wrapping<u8> as Add<Wrapping<u8>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<usize>> for &Wrapping<usize>

§

type Output = <Wrapping<usize> as Add<Wrapping<usize>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<usize> ) -> <Wrapping<usize> as Add<Wrapping<usize>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl Add<&Wrapping<usize>> for Wrapping<usize>

§

type Output = <Wrapping<usize> as Add<Wrapping<usize>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: &Wrapping<usize> ) -> <Wrapping<usize> as Add<Wrapping<usize>>>::Output

执行 + 操作。 Read more
1.14.0 · source§

impl<'a> Add<Wrapping<i128>> for &'a Wrapping<i128>

§

type Output = <Wrapping<i128> as Add<Wrapping<i128>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: Wrapping<i128> ) -> <Wrapping<i128> as Add<Wrapping<i128>>>::Output

执行 + 操作。 Read more
source§

impl Add<Wrapping<i128>> for Wrapping<i128>

§

type Output = Wrapping<i128>

应用 + 运算符后的结果类型。
source§

fn add(self, other: Wrapping<i128>) -> Wrapping<i128>

执行 + 操作。 Read more
1.14.0 · source§

impl<'a> Add<Wrapping<i16>> for &'a Wrapping<i16>

§

type Output = <Wrapping<i16> as Add<Wrapping<i16>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: Wrapping<i16> ) -> <Wrapping<i16> as Add<Wrapping<i16>>>::Output

执行 + 操作。 Read more
source§

impl Add<Wrapping<i16>> for Wrapping<i16>

§

type Output = Wrapping<i16>

应用 + 运算符后的结果类型。
source§

fn add(self, other: Wrapping<i16>) -> Wrapping<i16>

执行 + 操作。 Read more
1.14.0 · source§

impl<'a> Add<Wrapping<i32>> for &'a Wrapping<i32>

§

type Output = <Wrapping<i32> as Add<Wrapping<i32>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: Wrapping<i32> ) -> <Wrapping<i32> as Add<Wrapping<i32>>>::Output

执行 + 操作。 Read more
source§

impl Add<Wrapping<i32>> for Wrapping<i32>

§

type Output = Wrapping<i32>

应用 + 运算符后的结果类型。
source§

fn add(self, other: Wrapping<i32>) -> Wrapping<i32>

执行 + 操作。 Read more
1.14.0 · source§

impl<'a> Add<Wrapping<i64>> for &'a Wrapping<i64>

§

type Output = <Wrapping<i64> as Add<Wrapping<i64>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: Wrapping<i64> ) -> <Wrapping<i64> as Add<Wrapping<i64>>>::Output

执行 + 操作。 Read more
source§

impl Add<Wrapping<i64>> for Wrapping<i64>

§

type Output = Wrapping<i64>

应用 + 运算符后的结果类型。
source§

fn add(self, other: Wrapping<i64>) -> Wrapping<i64>

执行 + 操作。 Read more
1.14.0 · source§

impl<'a> Add<Wrapping<i8>> for &'a Wrapping<i8>

§

type Output = <Wrapping<i8> as Add<Wrapping<i8>>>::Output

应用 + 运算符后的结果类型。
source§

fn add(self, other: Wrapping<i8>) -> <Wrapping<i8> as Add<Wrapping<i8>>>::Output

执行 + 操作。 Read more
source§

impl Add<Wrapping<i8>> for Wrapping<i8>

§

type Output = Wrapping<i8>

应用 + 运算符后的结果类型。
source§

fn add(self, other: Wrapping<i8>) -> Wrapping<i8>

执行 + 操作。 Read more
1.14.0 · source§

impl<'a> Add<Wrapping<isize>> for &'a Wrapping<isize>

§

type Output = <Wrapping<isize> as Add<Wrapping<isize>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: Wrapping<isize> ) -> <Wrapping<isize> as Add<Wrapping<isize>>>::Output

执行 + 操作。 Read more
source§

impl Add<Wrapping<isize>> for Wrapping<isize>

§

type Output = Wrapping<isize>

应用 + 运算符后的结果类型。
source§

fn add(self, other: Wrapping<isize>) -> Wrapping<isize>

执行 + 操作。 Read more
1.14.0 · source§

impl<'a> Add<Wrapping<u128>> for &'a Wrapping<u128>

§

type Output = <Wrapping<u128> as Add<Wrapping<u128>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: Wrapping<u128> ) -> <Wrapping<u128> as Add<Wrapping<u128>>>::Output

执行 + 操作。 Read more
source§

impl Add<Wrapping<u128>> for Wrapping<u128>

§

type Output = Wrapping<u128>

应用 + 运算符后的结果类型。
source§

fn add(self, other: Wrapping<u128>) -> Wrapping<u128>

执行 + 操作。 Read more
1.14.0 · source§

impl<'a> Add<Wrapping<u16>> for &'a Wrapping<u16>

§

type Output = <Wrapping<u16> as Add<Wrapping<u16>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: Wrapping<u16> ) -> <Wrapping<u16> as Add<Wrapping<u16>>>::Output

执行 + 操作。 Read more
source§

impl Add<Wrapping<u16>> for Wrapping<u16>

§

type Output = Wrapping<u16>

应用 + 运算符后的结果类型。
source§

fn add(self, other: Wrapping<u16>) -> Wrapping<u16>

执行 + 操作。 Read more
1.14.0 · source§

impl<'a> Add<Wrapping<u32>> for &'a Wrapping<u32>

§

type Output = <Wrapping<u32> as Add<Wrapping<u32>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: Wrapping<u32> ) -> <Wrapping<u32> as Add<Wrapping<u32>>>::Output

执行 + 操作。 Read more
source§

impl Add<Wrapping<u32>> for Wrapping<u32>

§

type Output = Wrapping<u32>

应用 + 运算符后的结果类型。
source§

fn add(self, other: Wrapping<u32>) -> Wrapping<u32>

执行 + 操作。 Read more
1.14.0 · source§

impl<'a> Add<Wrapping<u64>> for &'a Wrapping<u64>

§

type Output = <Wrapping<u64> as Add<Wrapping<u64>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: Wrapping<u64> ) -> <Wrapping<u64> as Add<Wrapping<u64>>>::Output

执行 + 操作。 Read more
source§

impl Add<Wrapping<u64>> for Wrapping<u64>

§

type Output = Wrapping<u64>

应用 + 运算符后的结果类型。
source§

fn add(self, other: Wrapping<u64>) -> Wrapping<u64>

执行 + 操作。 Read more
1.14.0 · source§

impl<'a> Add<Wrapping<u8>> for &'a Wrapping<u8>

§

type Output = <Wrapping<u8> as Add<Wrapping<u8>>>::Output

应用 + 运算符后的结果类型。
source§

fn add(self, other: Wrapping<u8>) -> <Wrapping<u8> as Add<Wrapping<u8>>>::Output

执行 + 操作。 Read more
source§

impl Add<Wrapping<u8>> for Wrapping<u8>

§

type Output = Wrapping<u8>

应用 + 运算符后的结果类型。
source§

fn add(self, other: Wrapping<u8>) -> Wrapping<u8>

执行 + 操作。 Read more
1.14.0 · source§

impl<'a> Add<Wrapping<usize>> for &'a Wrapping<usize>

§

type Output = <Wrapping<usize> as Add<Wrapping<usize>>>::Output

应用 + 运算符后的结果类型。
source§

fn add( self, other: Wrapping<usize> ) -> <Wrapping<usize> as Add<Wrapping<usize>>>::Output

执行 + 操作。 Read more
source§

impl Add<Wrapping<usize>> for Wrapping<usize>

§

type Output = Wrapping<usize>

应用 + 运算符后的结果类型。
source§

fn add(self, other: Wrapping<usize>) -> Wrapping<usize>

执行 + 操作。 Read more
1.22.0 · source§

impl AddAssign<&Wrapping<i128>> for Wrapping<i128>

source§

fn add_assign(&mut self, other: &Wrapping<i128>)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&Wrapping<i16>> for Wrapping<i16>

source§

fn add_assign(&mut self, other: &Wrapping<i16>)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&Wrapping<i32>> for Wrapping<i32>

source§

fn add_assign(&mut self, other: &Wrapping<i32>)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&Wrapping<i64>> for Wrapping<i64>

source§

fn add_assign(&mut self, other: &Wrapping<i64>)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&Wrapping<i8>> for Wrapping<i8>

source§

fn add_assign(&mut self, other: &Wrapping<i8>)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&Wrapping<isize>> for Wrapping<isize>

source§

fn add_assign(&mut self, other: &Wrapping<isize>)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&Wrapping<u128>> for Wrapping<u128>

source§

fn add_assign(&mut self, other: &Wrapping<u128>)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&Wrapping<u16>> for Wrapping<u16>

source§

fn add_assign(&mut self, other: &Wrapping<u16>)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&Wrapping<u32>> for Wrapping<u32>

source§

fn add_assign(&mut self, other: &Wrapping<u32>)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&Wrapping<u64>> for Wrapping<u64>

source§

fn add_assign(&mut self, other: &Wrapping<u64>)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&Wrapping<u8>> for Wrapping<u8>

source§

fn add_assign(&mut self, other: &Wrapping<u8>)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&Wrapping<usize>> for Wrapping<usize>

source§

fn add_assign(&mut self, other: &Wrapping<usize>)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&i128> for Wrapping<i128>

source§

fn add_assign(&mut self, other: &i128)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&i16> for Wrapping<i16>

source§

fn add_assign(&mut self, other: &i16)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&i32> for Wrapping<i32>

source§

fn add_assign(&mut self, other: &i32)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&i64> for Wrapping<i64>

source§

fn add_assign(&mut self, other: &i64)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&i8> for Wrapping<i8>

source§

fn add_assign(&mut self, other: &i8)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&isize> for Wrapping<isize>

source§

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

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&u128> for Wrapping<u128>

source§

fn add_assign(&mut self, other: &u128)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&u16> for Wrapping<u16>

source§

fn add_assign(&mut self, other: &u16)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&u32> for Wrapping<u32>

source§

fn add_assign(&mut self, other: &u32)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&u64> for Wrapping<u64>

source§

fn add_assign(&mut self, other: &u64)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&u8> for Wrapping<u8>

source§

fn add_assign(&mut self, other: &u8)

执行 += 操作。 Read more
1.22.0 · source§

impl AddAssign<&usize> for Wrapping<usize>

source§

fn add_assign(&mut self, other: &usize)

执行 += 操作。 Read more
1.8.0 · source§

impl AddAssign<Wrapping<i128>> for Wrapping<i128>

source§

fn add_assign(&mut self, other: Wrapping<i128>)

执行 += 操作。 Read more
1.8.0 · source§

impl AddAssign<Wrapping<i16>> for Wrapping<i16>

source§

fn add_assign(&mut self, other: Wrapping<i16>)

执行 += 操作。 Read more
1.8.0 · source§

impl AddAssign<Wrapping<i32>> for Wrapping<i32>

source§

fn add_assign(&mut self, other: Wrapping<i32>)

执行 += 操作。 Read more
1.8.0 · source§

impl AddAssign<Wrapping<i64>> for Wrapping<i64>

source§

fn add_assign(&mut self, other: Wrapping<i64>)

执行 += 操作。 Read more
1.8.0 · source§

impl AddAssign<Wrapping<i8>> for Wrapping<i8>

source§

fn add_assign(&mut self, other: Wrapping<i8>)

执行 += 操作。 Read more
1.8.0 · source§

impl AddAssign<Wrapping<isize>> for Wrapping<isize>

source§

fn add_assign(&mut self, other: Wrapping<isize>)

执行 += 操作。 Read more
1.8.0 · source§

impl AddAssign<Wrapping<u128>> for Wrapping<u128>

source§

fn add_assign(&mut self, other: Wrapping<u128>)

执行 += 操作。 Read more
1.8.0 · source§

impl AddAssign<Wrapping<u16>> for Wrapping<u16>

source§

fn add_assign(&mut self, other: Wrapping<u16>)

执行 += 操作。 Read more
1.8.0 · source§

impl AddAssign<Wrapping<u32>> for Wrapping<u32>

source§

fn add_assign(&mut self, other: Wrapping<u32>)

执行 += 操作。 Read more
1.8.0 · source§

impl AddAssign<Wrapping<u64>> for Wrapping<u64>

source§

fn add_assign(&mut self, other: Wrapping<u64>)

执行 += 操作。 Read more
1.8.0 · source§

impl AddAssign<Wrapping<u8>> for Wrapping<u8>

source§

fn add_assign(&mut self, other: Wrapping<u8>)

执行 += 操作。 Read more
1.8.0 · source§

impl AddAssign<Wrapping<usize>> for Wrapping<usize>

source§

fn add_assign(&mut self, other: Wrapping<usize>)

执行 += 操作。 Read more
1.60.0 · source§

impl AddAssign<i128> for Wrapping<i128>

source§

fn add_assign(&mut self, other: i128)

执行 += 操作。 Read more
1.60.0 · source§

impl AddAssign<i16> for Wrapping<i16>

source§

fn add_assign(&mut self, other: i16)

执行 += 操作。 Read more
1.60.0 · source§

impl AddAssign<i32> for Wrapping<i32>

source§

fn add_assign(&mut self, other: i32)

执行 += 操作。 Read more
1.60.0 · source§

impl AddAssign<i64> for Wrapping<i64>

source§

fn add_assign(&mut self, other: i64)

执行 += 操作。 Read more
1.60.0 · source§

impl AddAssign<i8> for Wrapping<i8>

source§

fn add_assign(&mut self, other: i8)

执行 += 操作。 Read more
1.60.0 · source§

impl AddAssign<isize> for Wrapping<isize>

source§

fn add_assign(&mut self, other: isize)

执行 += 操作。 Read more
1.60.0 · source§

impl AddAssign<u128> for Wrapping<u128>

source§

fn add_assign(&mut self, other: u128)

执行 += 操作。 Read more
1.60.0 · source§

impl AddAssign<u16> for Wrapping<u16>

source§

fn add_assign(&mut self, other: u16)

执行 += 操作。 Read more
1.60.0 · source§

impl AddAssign<u32> for Wrapping<u32>

source§

fn add_assign(&mut self, other: u32)

执行 += 操作。 Read more
1.60.0 · source§

impl AddAssign<u64> for Wrapping<u64>

source§

fn add_assign(&mut self, other: u64)

执行 += 操作。 Read more
1.60.0 · source§

impl AddAssign<u8> for Wrapping<u8>

source§

fn add_assign(&mut self, other: u8)

执行 += 操作。 Read more
1.60.0 · source§

impl AddAssign<usize> for Wrapping<usize>

source§

fn add_assign(&mut self, other: usize)

执行 += 操作。 Read more
1.11.0 · source§

impl<T> Binary for Wrapping<T>where T: Binary,

source§

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

使用给定的格式化程序格式化该值。
1.14.0 · source§

impl BitAnd<&Wrapping<i128>> for &Wrapping<i128>

§

type Output = <Wrapping<i128> as BitAnd<Wrapping<i128>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<i128> ) -> <Wrapping<i128> as BitAnd<Wrapping<i128>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<i128>> for Wrapping<i128>

§

type Output = <Wrapping<i128> as BitAnd<Wrapping<i128>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<i128> ) -> <Wrapping<i128> as BitAnd<Wrapping<i128>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<i16>> for &Wrapping<i16>

§

type Output = <Wrapping<i16> as BitAnd<Wrapping<i16>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<i16> ) -> <Wrapping<i16> as BitAnd<Wrapping<i16>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<i16>> for Wrapping<i16>

§

type Output = <Wrapping<i16> as BitAnd<Wrapping<i16>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<i16> ) -> <Wrapping<i16> as BitAnd<Wrapping<i16>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<i32>> for &Wrapping<i32>

§

type Output = <Wrapping<i32> as BitAnd<Wrapping<i32>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<i32> ) -> <Wrapping<i32> as BitAnd<Wrapping<i32>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<i32>> for Wrapping<i32>

§

type Output = <Wrapping<i32> as BitAnd<Wrapping<i32>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<i32> ) -> <Wrapping<i32> as BitAnd<Wrapping<i32>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<i64>> for &Wrapping<i64>

§

type Output = <Wrapping<i64> as BitAnd<Wrapping<i64>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<i64> ) -> <Wrapping<i64> as BitAnd<Wrapping<i64>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<i64>> for Wrapping<i64>

§

type Output = <Wrapping<i64> as BitAnd<Wrapping<i64>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<i64> ) -> <Wrapping<i64> as BitAnd<Wrapping<i64>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<i8>> for &Wrapping<i8>

§

type Output = <Wrapping<i8> as BitAnd<Wrapping<i8>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<i8> ) -> <Wrapping<i8> as BitAnd<Wrapping<i8>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<i8>> for Wrapping<i8>

§

type Output = <Wrapping<i8> as BitAnd<Wrapping<i8>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<i8> ) -> <Wrapping<i8> as BitAnd<Wrapping<i8>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<isize>> for &Wrapping<isize>

§

type Output = <Wrapping<isize> as BitAnd<Wrapping<isize>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<isize> ) -> <Wrapping<isize> as BitAnd<Wrapping<isize>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<isize>> for Wrapping<isize>

§

type Output = <Wrapping<isize> as BitAnd<Wrapping<isize>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<isize> ) -> <Wrapping<isize> as BitAnd<Wrapping<isize>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<u128>> for &Wrapping<u128>

§

type Output = <Wrapping<u128> as BitAnd<Wrapping<u128>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<u128> ) -> <Wrapping<u128> as BitAnd<Wrapping<u128>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<u128>> for Wrapping<u128>

§

type Output = <Wrapping<u128> as BitAnd<Wrapping<u128>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<u128> ) -> <Wrapping<u128> as BitAnd<Wrapping<u128>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<u16>> for &Wrapping<u16>

§

type Output = <Wrapping<u16> as BitAnd<Wrapping<u16>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<u16> ) -> <Wrapping<u16> as BitAnd<Wrapping<u16>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<u16>> for Wrapping<u16>

§

type Output = <Wrapping<u16> as BitAnd<Wrapping<u16>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<u16> ) -> <Wrapping<u16> as BitAnd<Wrapping<u16>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<u32>> for &Wrapping<u32>

§

type Output = <Wrapping<u32> as BitAnd<Wrapping<u32>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<u32> ) -> <Wrapping<u32> as BitAnd<Wrapping<u32>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<u32>> for Wrapping<u32>

§

type Output = <Wrapping<u32> as BitAnd<Wrapping<u32>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<u32> ) -> <Wrapping<u32> as BitAnd<Wrapping<u32>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<u64>> for &Wrapping<u64>

§

type Output = <Wrapping<u64> as BitAnd<Wrapping<u64>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<u64> ) -> <Wrapping<u64> as BitAnd<Wrapping<u64>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<u64>> for Wrapping<u64>

§

type Output = <Wrapping<u64> as BitAnd<Wrapping<u64>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<u64> ) -> <Wrapping<u64> as BitAnd<Wrapping<u64>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<u8>> for &Wrapping<u8>

§

type Output = <Wrapping<u8> as BitAnd<Wrapping<u8>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<u8> ) -> <Wrapping<u8> as BitAnd<Wrapping<u8>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<u8>> for Wrapping<u8>

§

type Output = <Wrapping<u8> as BitAnd<Wrapping<u8>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<u8> ) -> <Wrapping<u8> as BitAnd<Wrapping<u8>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<usize>> for &Wrapping<usize>

§

type Output = <Wrapping<usize> as BitAnd<Wrapping<usize>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<usize> ) -> <Wrapping<usize> as BitAnd<Wrapping<usize>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl BitAnd<&Wrapping<usize>> for Wrapping<usize>

§

type Output = <Wrapping<usize> as BitAnd<Wrapping<usize>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: &Wrapping<usize> ) -> <Wrapping<usize> as BitAnd<Wrapping<usize>>>::Output

执行 & 操作。 Read more
1.14.0 · source§

impl<'a> BitAnd<Wrapping<i128>> for &'a Wrapping<i128>

§

type Output = <Wrapping<i128> as BitAnd<Wrapping<i128>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: Wrapping<i128> ) -> <Wrapping<i128> as BitAnd<Wrapping<i128>>>::Output

执行 & 操作。 Read more
source§

impl BitAnd<Wrapping<i128>> for Wrapping<i128>

§

type Output = Wrapping<i128>

应用 & 运算符后的结果类型。
source§

fn bitand(self, other: Wrapping<i128>) -> Wrapping<i128>

执行 & 操作。 Read more
1.14.0 · source§

impl<'a> BitAnd<Wrapping<i16>> for &'a Wrapping<i16>

§

type Output = <Wrapping<i16> as BitAnd<Wrapping<i16>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: Wrapping<i16> ) -> <Wrapping<i16> as BitAnd<Wrapping<i16>>>::Output

执行 & 操作。 Read more
source§

impl BitAnd<Wrapping<i16>> for Wrapping<i16>

§

type Output = Wrapping<i16>

应用 & 运算符后的结果类型。
source§

fn bitand(self, other: Wrapping<i16>) -> Wrapping<i16>

执行 & 操作。 Read more
1.14.0 · source§

impl<'a> BitAnd<Wrapping<i32>> for &'a Wrapping<i32>

§

type Output = <Wrapping<i32> as BitAnd<Wrapping<i32>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: Wrapping<i32> ) -> <Wrapping<i32> as BitAnd<Wrapping<i32>>>::Output

执行 & 操作。 Read more
source§

impl BitAnd<Wrapping<i32>> for Wrapping<i32>

§

type Output = Wrapping<i32>

应用 & 运算符后的结果类型。
source§

fn bitand(self, other: Wrapping<i32>) -> Wrapping<i32>

执行 & 操作。 Read more
1.14.0 · source§

impl<'a> BitAnd<Wrapping<i64>> for &'a Wrapping<i64>

§

type Output = <Wrapping<i64> as BitAnd<Wrapping<i64>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: Wrapping<i64> ) -> <Wrapping<i64> as BitAnd<Wrapping<i64>>>::Output

执行 & 操作。 Read more
source§

impl BitAnd<Wrapping<i64>> for Wrapping<i64>

§

type Output = Wrapping<i64>

应用 & 运算符后的结果类型。
source§

fn bitand(self, other: Wrapping<i64>) -> Wrapping<i64>

执行 & 操作。 Read more
1.14.0 · source§

impl<'a> BitAnd<Wrapping<i8>> for &'a Wrapping<i8>

§

type Output = <Wrapping<i8> as BitAnd<Wrapping<i8>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: Wrapping<i8> ) -> <Wrapping<i8> as BitAnd<Wrapping<i8>>>::Output

执行 & 操作。 Read more
source§

impl BitAnd<Wrapping<i8>> for Wrapping<i8>

§

type Output = Wrapping<i8>

应用 & 运算符后的结果类型。
source§

fn bitand(self, other: Wrapping<i8>) -> Wrapping<i8>

执行 & 操作。 Read more
1.14.0 · source§

impl<'a> BitAnd<Wrapping<isize>> for &'a Wrapping<isize>

§

type Output = <Wrapping<isize> as BitAnd<Wrapping<isize>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: Wrapping<isize> ) -> <Wrapping<isize> as BitAnd<Wrapping<isize>>>::Output

执行 & 操作。 Read more
source§

impl BitAnd<Wrapping<isize>> for Wrapping<isize>

§

type Output = Wrapping<isize>

应用 & 运算符后的结果类型。
source§

fn bitand(self, other: Wrapping<isize>) -> Wrapping<isize>

执行 & 操作。 Read more
1.14.0 · source§

impl<'a> BitAnd<Wrapping<u128>> for &'a Wrapping<u128>

§

type Output = <Wrapping<u128> as BitAnd<Wrapping<u128>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: Wrapping<u128> ) -> <Wrapping<u128> as BitAnd<Wrapping<u128>>>::Output

执行 & 操作。 Read more
source§

impl BitAnd<Wrapping<u128>> for Wrapping<u128>

§

type Output = Wrapping<u128>

应用 & 运算符后的结果类型。
source§

fn bitand(self, other: Wrapping<u128>) -> Wrapping<u128>

执行 & 操作。 Read more
1.14.0 · source§

impl<'a> BitAnd<Wrapping<u16>> for &'a Wrapping<u16>

§

type Output = <Wrapping<u16> as BitAnd<Wrapping<u16>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: Wrapping<u16> ) -> <Wrapping<u16> as BitAnd<Wrapping<u16>>>::Output

执行 & 操作。 Read more
source§

impl BitAnd<Wrapping<u16>> for Wrapping<u16>

§

type Output = Wrapping<u16>

应用 & 运算符后的结果类型。
source§

fn bitand(self, other: Wrapping<u16>) -> Wrapping<u16>

执行 & 操作。 Read more
1.14.0 · source§

impl<'a> BitAnd<Wrapping<u32>> for &'a Wrapping<u32>

§

type Output = <Wrapping<u32> as BitAnd<Wrapping<u32>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: Wrapping<u32> ) -> <Wrapping<u32> as BitAnd<Wrapping<u32>>>::Output

执行 & 操作。 Read more
source§

impl BitAnd<Wrapping<u32>> for Wrapping<u32>

§

type Output = Wrapping<u32>

应用 & 运算符后的结果类型。
source§

fn bitand(self, other: Wrapping<u32>) -> Wrapping<u32>

执行 & 操作。 Read more
1.14.0 · source§

impl<'a> BitAnd<Wrapping<u64>> for &'a Wrapping<u64>

§

type Output = <Wrapping<u64> as BitAnd<Wrapping<u64>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: Wrapping<u64> ) -> <Wrapping<u64> as BitAnd<Wrapping<u64>>>::Output

执行 & 操作。 Read more
source§

impl BitAnd<Wrapping<u64>> for Wrapping<u64>

§

type Output = Wrapping<u64>

应用 & 运算符后的结果类型。
source§

fn bitand(self, other: Wrapping<u64>) -> Wrapping<u64>

执行 & 操作。 Read more
1.14.0 · source§

impl<'a> BitAnd<Wrapping<u8>> for &'a Wrapping<u8>

§

type Output = <Wrapping<u8> as BitAnd<Wrapping<u8>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: Wrapping<u8> ) -> <Wrapping<u8> as BitAnd<Wrapping<u8>>>::Output

执行 & 操作。 Read more
source§

impl BitAnd<Wrapping<u8>> for Wrapping<u8>

§

type Output = Wrapping<u8>

应用 & 运算符后的结果类型。
source§

fn bitand(self, other: Wrapping<u8>) -> Wrapping<u8>

执行 & 操作。 Read more
1.14.0 · source§

impl<'a> BitAnd<Wrapping<usize>> for &'a Wrapping<usize>

§

type Output = <Wrapping<usize> as BitAnd<Wrapping<usize>>>::Output

应用 & 运算符后的结果类型。
source§

fn bitand( self, other: Wrapping<usize> ) -> <Wrapping<usize> as BitAnd<Wrapping<usize>>>::Output

执行 & 操作。 Read more
source§

impl BitAnd<Wrapping<usize>> for Wrapping<usize>

§

type Output = Wrapping<usize>

应用 & 运算符后的结果类型。
source§

fn bitand(self, other: Wrapping<usize>) -> Wrapping<usize>

执行 & 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&Wrapping<i128>> for Wrapping<i128>

source§

fn bitand_assign(&mut self, other: &Wrapping<i128>)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&Wrapping<i16>> for Wrapping<i16>

source§

fn bitand_assign(&mut self, other: &Wrapping<i16>)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&Wrapping<i32>> for Wrapping<i32>

source§

fn bitand_assign(&mut self, other: &Wrapping<i32>)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&Wrapping<i64>> for Wrapping<i64>

source§

fn bitand_assign(&mut self, other: &Wrapping<i64>)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&Wrapping<i8>> for Wrapping<i8>

source§

fn bitand_assign(&mut self, other: &Wrapping<i8>)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&Wrapping<isize>> for Wrapping<isize>

source§

fn bitand_assign(&mut self, other: &Wrapping<isize>)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&Wrapping<u128>> for Wrapping<u128>

source§

fn bitand_assign(&mut self, other: &Wrapping<u128>)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&Wrapping<u16>> for Wrapping<u16>

source§

fn bitand_assign(&mut self, other: &Wrapping<u16>)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&Wrapping<u32>> for Wrapping<u32>

source§

fn bitand_assign(&mut self, other: &Wrapping<u32>)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&Wrapping<u64>> for Wrapping<u64>

source§

fn bitand_assign(&mut self, other: &Wrapping<u64>)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&Wrapping<u8>> for Wrapping<u8>

source§

fn bitand_assign(&mut self, other: &Wrapping<u8>)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&Wrapping<usize>> for Wrapping<usize>

source§

fn bitand_assign(&mut self, other: &Wrapping<usize>)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&i128> for Wrapping<i128>

source§

fn bitand_assign(&mut self, other: &i128)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&i16> for Wrapping<i16>

source§

fn bitand_assign(&mut self, other: &i16)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&i32> for Wrapping<i32>

source§

fn bitand_assign(&mut self, other: &i32)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&i64> for Wrapping<i64>

source§

fn bitand_assign(&mut self, other: &i64)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&i8> for Wrapping<i8>

source§

fn bitand_assign(&mut self, other: &i8)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&isize> for Wrapping<isize>

source§

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

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&u128> for Wrapping<u128>

source§

fn bitand_assign(&mut self, other: &u128)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&u16> for Wrapping<u16>

source§

fn bitand_assign(&mut self, other: &u16)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&u32> for Wrapping<u32>

source§

fn bitand_assign(&mut self, other: &u32)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&u64> for Wrapping<u64>

source§

fn bitand_assign(&mut self, other: &u64)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&u8> for Wrapping<u8>

source§

fn bitand_assign(&mut self, other: &u8)

执行 &= 操作。 Read more
1.22.0 · source§

impl BitAndAssign<&usize> for Wrapping<usize>

source§

fn bitand_assign(&mut self, other: &usize)

执行 &= 操作。 Read more
1.8.0 · source§

impl BitAndAssign<Wrapping<i128>> for Wrapping<i128>

source§

fn bitand_assign(&mut self, other: Wrapping<i128>)

执行 &= 操作。 Read more
1.8.0 · source§

impl BitAndAssign<Wrapping<i16>> for Wrapping<i16>

source§

fn bitand_assign(&mut self, other: Wrapping<i16>)

执行 &= 操作。 Read more
1.8.0 · source§

impl BitAndAssign<Wrapping<i32>> for Wrapping<i32>

source§

fn bitand_assign(&mut self, other: Wrapping<i32>)

执行 &= 操作。 Read more
1.8.0 · source§

impl BitAndAssign<Wrapping<i64>> for Wrapping<i64>

source§

fn bitand_assign(&mut self, other: Wrapping<i64>)

执行 &= 操作。 Read more
1.8.0 · source§

impl BitAndAssign<Wrapping<i8>> for Wrapping<i8>

source§

fn bitand_assign(&mut self, other: Wrapping<i8>)

执行 &= 操作。 Read more
1.8.0 · source§

impl BitAndAssign<Wrapping<isize>> for Wrapping<isize>

source§

fn bitand_assign(&mut self, other: Wrapping<isize>)

执行 &= 操作。 Read more
1.8.0 · source§

impl BitAndAssign<Wrapping<u128>> for Wrapping<u128>

source§

fn bitand_assign(&mut self, other: Wrapping<u128>)

执行 &= 操作。 Read more
1.8.0 · source§

impl BitAndAssign<Wrapping<u16>> for Wrapping<u16>

source§

fn bitand_assign(&mut self, other: Wrapping<u16>)

执行 &= 操作。 Read more
1.8.0 · source§

impl BitAndAssign<Wrapping<u32>> for Wrapping<u32>

source§

fn bitand_assign(&mut self, other: Wrapping<u32>)

执行 &= 操作。 Read more
1.8.0 · source§

impl BitAndAssign<Wrapping<u64>> for Wrapping<u64>

source§

fn bitand_assign(&mut self, other: Wrapping<u64>)

执行 &= 操作。 Read more
1.8.0 · source§

impl BitAndAssign<Wrapping<u8>> for Wrapping<u8>

source§

fn bitand_assign(&mut self, other: Wrapping<u8>)

执行 &= 操作。 Read more
1.8.0 · source§

impl BitAndAssign<Wrapping<usize>> for Wrapping<usize>

source§

fn bitand_assign(&mut self, other: Wrapping<usize>)

执行 &= 操作。 Read more
1.60.0 · source§

impl BitAndAssign<i128> for Wrapping<i128>

source§

fn bitand_assign(&mut self, other: i128)

执行 &= 操作。 Read more
1.60.0 · source§

impl BitAndAssign<i16> for Wrapping<i16>

source§

fn bitand_assign(&mut self, other: i16)

执行 &= 操作。 Read more
1.60.0 · source§

impl BitAndAssign<i32> for Wrapping<i32>

source§

fn bitand_assign(&mut self, other: i32)

执行 &= 操作。 Read more
1.60.0 · source§

impl BitAndAssign<i64> for Wrapping<i64>

source§

fn bitand_assign(&mut self, other: i64)

执行 &= 操作。 Read more
1.60.0 · source§

impl BitAndAssign<i8> for Wrapping<i8>

source§

fn bitand_assign(&mut self, other: i8)

执行 &= 操作。 Read more
1.60.0 · source§

impl BitAndAssign<isize> for Wrapping<isize>

source§

fn bitand_assign(&mut self, other: isize)

执行 &= 操作。 Read more
1.60.0 · source§

impl BitAndAssign<u128> for Wrapping<u128>

source§

fn bitand_assign(&mut self, other: u128)

执行 &= 操作。 Read more
1.60.0 · source§

impl BitAndAssign<u16> for Wrapping<u16>

source§

fn bitand_assign(&mut self, other: u16)

执行 &= 操作。 Read more
1.60.0 · source§

impl BitAndAssign<u32> for Wrapping<u32>

source§

fn bitand_assign(&mut self, other: u32)

执行 &= 操作。 Read more
1.60.0 · source§

impl BitAndAssign<u64> for Wrapping<u64>

source§

fn bitand_assign(&mut self, other: u64)

执行 &= 操作。 Read more
1.60.0 · source§

impl BitAndAssign<u8> for Wrapping<u8>

source§

fn bitand_assign(&mut self, other: u8)

执行 &= 操作。 Read more
1.60.0 · source§

impl BitAndAssign<usize> for Wrapping<usize>

source§

fn bitand_assign(&mut self, other: usize)

执行 &= 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<i128>> for &Wrapping<i128>

§

type Output = <Wrapping<i128> as BitOr<Wrapping<i128>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<i128> ) -> <Wrapping<i128> as BitOr<Wrapping<i128>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<i128>> for Wrapping<i128>

§

type Output = <Wrapping<i128> as BitOr<Wrapping<i128>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<i128> ) -> <Wrapping<i128> as BitOr<Wrapping<i128>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<i16>> for &Wrapping<i16>

§

type Output = <Wrapping<i16> as BitOr<Wrapping<i16>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<i16> ) -> <Wrapping<i16> as BitOr<Wrapping<i16>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<i16>> for Wrapping<i16>

§

type Output = <Wrapping<i16> as BitOr<Wrapping<i16>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<i16> ) -> <Wrapping<i16> as BitOr<Wrapping<i16>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<i32>> for &Wrapping<i32>

§

type Output = <Wrapping<i32> as BitOr<Wrapping<i32>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<i32> ) -> <Wrapping<i32> as BitOr<Wrapping<i32>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<i32>> for Wrapping<i32>

§

type Output = <Wrapping<i32> as BitOr<Wrapping<i32>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<i32> ) -> <Wrapping<i32> as BitOr<Wrapping<i32>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<i64>> for &Wrapping<i64>

§

type Output = <Wrapping<i64> as BitOr<Wrapping<i64>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<i64> ) -> <Wrapping<i64> as BitOr<Wrapping<i64>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<i64>> for Wrapping<i64>

§

type Output = <Wrapping<i64> as BitOr<Wrapping<i64>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<i64> ) -> <Wrapping<i64> as BitOr<Wrapping<i64>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<i8>> for &Wrapping<i8>

§

type Output = <Wrapping<i8> as BitOr<Wrapping<i8>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<i8> ) -> <Wrapping<i8> as BitOr<Wrapping<i8>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<i8>> for Wrapping<i8>

§

type Output = <Wrapping<i8> as BitOr<Wrapping<i8>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<i8> ) -> <Wrapping<i8> as BitOr<Wrapping<i8>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<isize>> for &Wrapping<isize>

§

type Output = <Wrapping<isize> as BitOr<Wrapping<isize>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<isize> ) -> <Wrapping<isize> as BitOr<Wrapping<isize>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<isize>> for Wrapping<isize>

§

type Output = <Wrapping<isize> as BitOr<Wrapping<isize>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<isize> ) -> <Wrapping<isize> as BitOr<Wrapping<isize>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<u128>> for &Wrapping<u128>

§

type Output = <Wrapping<u128> as BitOr<Wrapping<u128>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<u128> ) -> <Wrapping<u128> as BitOr<Wrapping<u128>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<u128>> for Wrapping<u128>

§

type Output = <Wrapping<u128> as BitOr<Wrapping<u128>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<u128> ) -> <Wrapping<u128> as BitOr<Wrapping<u128>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<u16>> for &Wrapping<u16>

§

type Output = <Wrapping<u16> as BitOr<Wrapping<u16>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<u16> ) -> <Wrapping<u16> as BitOr<Wrapping<u16>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<u16>> for Wrapping<u16>

§

type Output = <Wrapping<u16> as BitOr<Wrapping<u16>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<u16> ) -> <Wrapping<u16> as BitOr<Wrapping<u16>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<u32>> for &Wrapping<u32>

§

type Output = <Wrapping<u32> as BitOr<Wrapping<u32>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<u32> ) -> <Wrapping<u32> as BitOr<Wrapping<u32>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<u32>> for Wrapping<u32>

§

type Output = <Wrapping<u32> as BitOr<Wrapping<u32>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<u32> ) -> <Wrapping<u32> as BitOr<Wrapping<u32>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<u64>> for &Wrapping<u64>

§

type Output = <Wrapping<u64> as BitOr<Wrapping<u64>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<u64> ) -> <Wrapping<u64> as BitOr<Wrapping<u64>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<u64>> for Wrapping<u64>

§

type Output = <Wrapping<u64> as BitOr<Wrapping<u64>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<u64> ) -> <Wrapping<u64> as BitOr<Wrapping<u64>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<u8>> for &Wrapping<u8>

§

type Output = <Wrapping<u8> as BitOr<Wrapping<u8>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<u8> ) -> <Wrapping<u8> as BitOr<Wrapping<u8>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<u8>> for Wrapping<u8>

§

type Output = <Wrapping<u8> as BitOr<Wrapping<u8>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<u8> ) -> <Wrapping<u8> as BitOr<Wrapping<u8>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<usize>> for &Wrapping<usize>

§

type Output = <Wrapping<usize> as BitOr<Wrapping<usize>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<usize> ) -> <Wrapping<usize> as BitOr<Wrapping<usize>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl BitOr<&Wrapping<usize>> for Wrapping<usize>

§

type Output = <Wrapping<usize> as BitOr<Wrapping<usize>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: &Wrapping<usize> ) -> <Wrapping<usize> as BitOr<Wrapping<usize>>>::Output

执行 | 操作。 Read more
1.14.0 · source§

impl<'a> BitOr<Wrapping<i128>> for &'a Wrapping<i128>

§

type Output = <Wrapping<i128> as BitOr<Wrapping<i128>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: Wrapping<i128> ) -> <Wrapping<i128> as BitOr<Wrapping<i128>>>::Output

执行 | 操作。 Read more
source§

impl BitOr<Wrapping<i128>> for Wrapping<i128>

§

type Output = Wrapping<i128>

应用 | 运算符后的结果类型。
source§

fn bitor(self, other: Wrapping<i128>) -> Wrapping<i128>

执行 | 操作。 Read more
1.14.0 · source§

impl<'a> BitOr<Wrapping<i16>> for &'a Wrapping<i16>

§

type Output = <Wrapping<i16> as BitOr<Wrapping<i16>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: Wrapping<i16> ) -> <Wrapping<i16> as BitOr<Wrapping<i16>>>::Output

执行 | 操作。 Read more
source§

impl BitOr<Wrapping<i16>> for Wrapping<i16>

§

type Output = Wrapping<i16>

应用 | 运算符后的结果类型。
source§

fn bitor(self, other: Wrapping<i16>) -> Wrapping<i16>

执行 | 操作。 Read more
1.14.0 · source§

impl<'a> BitOr<Wrapping<i32>> for &'a Wrapping<i32>

§

type Output = <Wrapping<i32> as BitOr<Wrapping<i32>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: Wrapping<i32> ) -> <Wrapping<i32> as BitOr<Wrapping<i32>>>::Output

执行 | 操作。 Read more
source§

impl BitOr<Wrapping<i32>> for Wrapping<i32>

§

type Output = Wrapping<i32>

应用 | 运算符后的结果类型。
source§

fn bitor(self, other: Wrapping<i32>) -> Wrapping<i32>

执行 | 操作。 Read more
1.14.0 · source§

impl<'a> BitOr<Wrapping<i64>> for &'a Wrapping<i64>

§

type Output = <Wrapping<i64> as BitOr<Wrapping<i64>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: Wrapping<i64> ) -> <Wrapping<i64> as BitOr<Wrapping<i64>>>::Output

执行 | 操作。 Read more
source§

impl BitOr<Wrapping<i64>> for Wrapping<i64>

§

type Output = Wrapping<i64>

应用 | 运算符后的结果类型。
source§

fn bitor(self, other: Wrapping<i64>) -> Wrapping<i64>

执行 | 操作。 Read more
1.14.0 · source§

impl<'a> BitOr<Wrapping<i8>> for &'a Wrapping<i8>

§

type Output = <Wrapping<i8> as BitOr<Wrapping<i8>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: Wrapping<i8> ) -> <Wrapping<i8> as BitOr<Wrapping<i8>>>::Output

执行 | 操作。 Read more
source§

impl BitOr<Wrapping<i8>> for Wrapping<i8>

§

type Output = Wrapping<i8>

应用 | 运算符后的结果类型。
source§

fn bitor(self, other: Wrapping<i8>) -> Wrapping<i8>

执行 | 操作。 Read more
1.14.0 · source§

impl<'a> BitOr<Wrapping<isize>> for &'a Wrapping<isize>

§

type Output = <Wrapping<isize> as BitOr<Wrapping<isize>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: Wrapping<isize> ) -> <Wrapping<isize> as BitOr<Wrapping<isize>>>::Output

执行 | 操作。 Read more
source§

impl BitOr<Wrapping<isize>> for Wrapping<isize>

§

type Output = Wrapping<isize>

应用 | 运算符后的结果类型。
source§

fn bitor(self, other: Wrapping<isize>) -> Wrapping<isize>

执行 | 操作。 Read more
1.14.0 · source§

impl<'a> BitOr<Wrapping<u128>> for &'a Wrapping<u128>

§

type Output = <Wrapping<u128> as BitOr<Wrapping<u128>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: Wrapping<u128> ) -> <Wrapping<u128> as BitOr<Wrapping<u128>>>::Output

执行 | 操作。 Read more
source§

impl BitOr<Wrapping<u128>> for Wrapping<u128>

§

type Output = Wrapping<u128>

应用 | 运算符后的结果类型。
source§

fn bitor(self, other: Wrapping<u128>) -> Wrapping<u128>

执行 | 操作。 Read more
1.14.0 · source§

impl<'a> BitOr<Wrapping<u16>> for &'a Wrapping<u16>

§

type Output = <Wrapping<u16> as BitOr<Wrapping<u16>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: Wrapping<u16> ) -> <Wrapping<u16> as BitOr<Wrapping<u16>>>::Output

执行 | 操作。 Read more
source§

impl BitOr<Wrapping<u16>> for Wrapping<u16>

§

type Output = Wrapping<u16>

应用 | 运算符后的结果类型。
source§

fn bitor(self, other: Wrapping<u16>) -> Wrapping<u16>

执行 | 操作。 Read more
1.14.0 · source§

impl<'a> BitOr<Wrapping<u32>> for &'a Wrapping<u32>

§

type Output = <Wrapping<u32> as BitOr<Wrapping<u32>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: Wrapping<u32> ) -> <Wrapping<u32> as BitOr<Wrapping<u32>>>::Output

执行 | 操作。 Read more
source§

impl BitOr<Wrapping<u32>> for Wrapping<u32>

§

type Output = Wrapping<u32>

应用 | 运算符后的结果类型。
source§

fn bitor(self, other: Wrapping<u32>) -> Wrapping<u32>

执行 | 操作。 Read more
1.14.0 · source§

impl<'a> BitOr<Wrapping<u64>> for &'a Wrapping<u64>

§

type Output = <Wrapping<u64> as BitOr<Wrapping<u64>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: Wrapping<u64> ) -> <Wrapping<u64> as BitOr<Wrapping<u64>>>::Output

执行 | 操作。 Read more
source§

impl BitOr<Wrapping<u64>> for Wrapping<u64>

§

type Output = Wrapping<u64>

应用 | 运算符后的结果类型。
source§

fn bitor(self, other: Wrapping<u64>) -> Wrapping<u64>

执行 | 操作。 Read more
1.14.0 · source§

impl<'a> BitOr<Wrapping<u8>> for &'a Wrapping<u8>

§

type Output = <Wrapping<u8> as BitOr<Wrapping<u8>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: Wrapping<u8> ) -> <Wrapping<u8> as BitOr<Wrapping<u8>>>::Output

执行 | 操作。 Read more
source§

impl BitOr<Wrapping<u8>> for Wrapping<u8>

§

type Output = Wrapping<u8>

应用 | 运算符后的结果类型。
source§

fn bitor(self, other: Wrapping<u8>) -> Wrapping<u8>

执行 | 操作。 Read more
1.14.0 · source§

impl<'a> BitOr<Wrapping<usize>> for &'a Wrapping<usize>

§

type Output = <Wrapping<usize> as BitOr<Wrapping<usize>>>::Output

应用 | 运算符后的结果类型。
source§

fn bitor( self, other: Wrapping<usize> ) -> <Wrapping<usize> as BitOr<Wrapping<usize>>>::Output

执行 | 操作。 Read more
source§

impl BitOr<Wrapping<usize>> for Wrapping<usize>

§

type Output = Wrapping<usize>

应用 | 运算符后的结果类型。
source§

fn bitor(self, other: Wrapping<usize>) -> Wrapping<usize>

执行 | 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&Wrapping<i128>> for Wrapping<i128>

source§

fn bitor_assign(&mut self, other: &Wrapping<i128>)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&Wrapping<i16>> for Wrapping<i16>

source§

fn bitor_assign(&mut self, other: &Wrapping<i16>)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&Wrapping<i32>> for Wrapping<i32>

source§

fn bitor_assign(&mut self, other: &Wrapping<i32>)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&Wrapping<i64>> for Wrapping<i64>

source§

fn bitor_assign(&mut self, other: &Wrapping<i64>)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&Wrapping<i8>> for Wrapping<i8>

source§

fn bitor_assign(&mut self, other: &Wrapping<i8>)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&Wrapping<isize>> for Wrapping<isize>

source§

fn bitor_assign(&mut self, other: &Wrapping<isize>)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&Wrapping<u128>> for Wrapping<u128>

source§

fn bitor_assign(&mut self, other: &Wrapping<u128>)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&Wrapping<u16>> for Wrapping<u16>

source§

fn bitor_assign(&mut self, other: &Wrapping<u16>)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&Wrapping<u32>> for Wrapping<u32>

source§

fn bitor_assign(&mut self, other: &Wrapping<u32>)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&Wrapping<u64>> for Wrapping<u64>

source§

fn bitor_assign(&mut self, other: &Wrapping<u64>)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&Wrapping<u8>> for Wrapping<u8>

source§

fn bitor_assign(&mut self, other: &Wrapping<u8>)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&Wrapping<usize>> for Wrapping<usize>

source§

fn bitor_assign(&mut self, other: &Wrapping<usize>)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&i128> for Wrapping<i128>

source§

fn bitor_assign(&mut self, other: &i128)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&i16> for Wrapping<i16>

source§

fn bitor_assign(&mut self, other: &i16)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&i32> for Wrapping<i32>

source§

fn bitor_assign(&mut self, other: &i32)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&i64> for Wrapping<i64>

source§

fn bitor_assign(&mut self, other: &i64)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&i8> for Wrapping<i8>

source§

fn bitor_assign(&mut self, other: &i8)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&isize> for Wrapping<isize>

source§

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

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&u128> for Wrapping<u128>

source§

fn bitor_assign(&mut self, other: &u128)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&u16> for Wrapping<u16>

source§

fn bitor_assign(&mut self, other: &u16)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&u32> for Wrapping<u32>

source§

fn bitor_assign(&mut self, other: &u32)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&u64> for Wrapping<u64>

source§

fn bitor_assign(&mut self, other: &u64)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&u8> for Wrapping<u8>

source§

fn bitor_assign(&mut self, other: &u8)

执行 |= 操作。 Read more
1.22.0 · source§

impl BitOrAssign<&usize> for Wrapping<usize>

source§

fn bitor_assign(&mut self, other: &usize)

执行 |= 操作。 Read more
1.8.0 · source§

impl BitOrAssign<Wrapping<i128>> for Wrapping<i128>

source§

fn bitor_assign(&mut self, other: Wrapping<i128>)

执行 |= 操作。 Read more
1.8.0 · source§

impl BitOrAssign<Wrapping<i16>> for Wrapping<i16>

source§

fn bitor_assign(&mut self, other: Wrapping<i16>)

执行 |= 操作。 Read more
1.8.0 · source§

impl BitOrAssign<Wrapping<i32>> for Wrapping<i32>

source§

fn bitor_assign(&mut self, other: Wrapping<i32>)

执行 |= 操作。 Read more
1.8.0 · source§

impl BitOrAssign<Wrapping<i64>> for Wrapping<i64>

source§

fn bitor_assign(&mut self, other: Wrapping<i64>)

执行 |= 操作。 Read more
1.8.0 · source§

impl BitOrAssign<Wrapping<i8>> for Wrapping<i8>

source§

fn bitor_assign(&mut self, other: Wrapping<i8>)

执行 |= 操作。 Read more
1.8.0 · source§

impl BitOrAssign<Wrapping<isize>> for Wrapping<isize>

source§

fn bitor_assign(&mut self, other: Wrapping<isize>)

执行 |= 操作。 Read more
1.8.0 · source§

impl BitOrAssign<Wrapping<u128>> for Wrapping<u128>

source§

fn bitor_assign(&mut self, other: Wrapping<u128>)

执行 |= 操作。 Read more
1.8.0 · source§

impl BitOrAssign<Wrapping<u16>> for Wrapping<u16>

source§

fn bitor_assign(&mut self, other: Wrapping<u16>)

执行 |= 操作。 Read more
1.8.0 · source§

impl BitOrAssign<Wrapping<u32>> for Wrapping<u32>

source§

fn bitor_assign(&mut self, other: Wrapping<u32>)

执行 |= 操作。 Read more
1.8.0 · source§

impl BitOrAssign<Wrapping<u64>> for Wrapping<u64>

source§

fn bitor_assign(&mut self, other: Wrapping<u64>)

执行 |= 操作。 Read more
1.8.0 · source§

impl BitOrAssign<Wrapping<u8>> for Wrapping<u8>

source§

fn bitor_assign(&mut self, other: Wrapping<u8>)

执行 |= 操作。 Read more
1.8.0 · source§

impl BitOrAssign<Wrapping<usize>> for Wrapping<usize>

source§

fn bitor_assign(&mut self, other: Wrapping<usize>)

执行 |= 操作。 Read more
1.60.0 · source§

impl BitOrAssign<i128> for Wrapping<i128>

source§

fn bitor_assign(&mut self, other: i128)

执行 |= 操作。 Read more
1.60.0 · source§

impl BitOrAssign<i16> for Wrapping<i16>

source§

fn bitor_assign(&mut self, other: i16)

执行 |= 操作。 Read more
1.60.0 · source§

impl BitOrAssign<i32> for Wrapping<i32>

source§

fn bitor_assign(&mut self, other: i32)

执行 |= 操作。 Read more
1.60.0 · source§

impl BitOrAssign<i64> for Wrapping<i64>

source§

fn bitor_assign(&mut self, other: i64)

执行 |= 操作。 Read more
1.60.0 · source§

impl BitOrAssign<i8> for Wrapping<i8>

source§

fn bitor_assign(&mut self, other: i8)

执行 |= 操作。 Read more
1.60.0 · source§

impl BitOrAssign<isize> for Wrapping<isize>

source§

fn bitor_assign(&mut self, other: isize)

执行 |= 操作。 Read more
1.60.0 · source§

impl BitOrAssign<u128> for Wrapping<u128>

source§

fn bitor_assign(&mut self, other: u128)

执行 |= 操作。 Read more
1.60.0 · source§

impl BitOrAssign<u16> for Wrapping<u16>

source§

fn bitor_assign(&mut self, other: u16)

执行 |= 操作。 Read more
1.60.0 · source§

impl BitOrAssign<u32> for Wrapping<u32>

source§

fn bitor_assign(&mut self, other: u32)

执行 |= 操作。 Read more
1.60.0 · source§

impl BitOrAssign<u64> for Wrapping<u64>

source§

fn bitor_assign(&mut self, other: u64)

执行 |= 操作。 Read more
1.60.0 · source§

impl BitOrAssign<u8> for Wrapping<u8>

source§

fn bitor_assign(&mut self, other: u8)

执行 |= 操作。 Read more
1.60.0 · source§

impl BitOrAssign<usize> for Wrapping<usize>

source§

fn bitor_assign(&mut self, other: usize)

执行 |= 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<i128>> for &Wrapping<i128>

§

type Output = <Wrapping<i128> as BitXor<Wrapping<i128>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<i128> ) -> <Wrapping<i128> as BitXor<Wrapping<i128>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<i128>> for Wrapping<i128>

§

type Output = <Wrapping<i128> as BitXor<Wrapping<i128>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<i128> ) -> <Wrapping<i128> as BitXor<Wrapping<i128>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<i16>> for &Wrapping<i16>

§

type Output = <Wrapping<i16> as BitXor<Wrapping<i16>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<i16> ) -> <Wrapping<i16> as BitXor<Wrapping<i16>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<i16>> for Wrapping<i16>

§

type Output = <Wrapping<i16> as BitXor<Wrapping<i16>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<i16> ) -> <Wrapping<i16> as BitXor<Wrapping<i16>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<i32>> for &Wrapping<i32>

§

type Output = <Wrapping<i32> as BitXor<Wrapping<i32>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<i32> ) -> <Wrapping<i32> as BitXor<Wrapping<i32>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<i32>> for Wrapping<i32>

§

type Output = <Wrapping<i32> as BitXor<Wrapping<i32>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<i32> ) -> <Wrapping<i32> as BitXor<Wrapping<i32>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<i64>> for &Wrapping<i64>

§

type Output = <Wrapping<i64> as BitXor<Wrapping<i64>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<i64> ) -> <Wrapping<i64> as BitXor<Wrapping<i64>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<i64>> for Wrapping<i64>

§

type Output = <Wrapping<i64> as BitXor<Wrapping<i64>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<i64> ) -> <Wrapping<i64> as BitXor<Wrapping<i64>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<i8>> for &Wrapping<i8>

§

type Output = <Wrapping<i8> as BitXor<Wrapping<i8>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<i8> ) -> <Wrapping<i8> as BitXor<Wrapping<i8>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<i8>> for Wrapping<i8>

§

type Output = <Wrapping<i8> as BitXor<Wrapping<i8>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<i8> ) -> <Wrapping<i8> as BitXor<Wrapping<i8>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<isize>> for &Wrapping<isize>

§

type Output = <Wrapping<isize> as BitXor<Wrapping<isize>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<isize> ) -> <Wrapping<isize> as BitXor<Wrapping<isize>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<isize>> for Wrapping<isize>

§

type Output = <Wrapping<isize> as BitXor<Wrapping<isize>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<isize> ) -> <Wrapping<isize> as BitXor<Wrapping<isize>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<u128>> for &Wrapping<u128>

§

type Output = <Wrapping<u128> as BitXor<Wrapping<u128>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<u128> ) -> <Wrapping<u128> as BitXor<Wrapping<u128>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<u128>> for Wrapping<u128>

§

type Output = <Wrapping<u128> as BitXor<Wrapping<u128>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<u128> ) -> <Wrapping<u128> as BitXor<Wrapping<u128>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<u16>> for &Wrapping<u16>

§

type Output = <Wrapping<u16> as BitXor<Wrapping<u16>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<u16> ) -> <Wrapping<u16> as BitXor<Wrapping<u16>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<u16>> for Wrapping<u16>

§

type Output = <Wrapping<u16> as BitXor<Wrapping<u16>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<u16> ) -> <Wrapping<u16> as BitXor<Wrapping<u16>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<u32>> for &Wrapping<u32>

§

type Output = <Wrapping<u32> as BitXor<Wrapping<u32>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<u32> ) -> <Wrapping<u32> as BitXor<Wrapping<u32>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<u32>> for Wrapping<u32>

§

type Output = <Wrapping<u32> as BitXor<Wrapping<u32>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<u32> ) -> <Wrapping<u32> as BitXor<Wrapping<u32>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<u64>> for &Wrapping<u64>

§

type Output = <Wrapping<u64> as BitXor<Wrapping<u64>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<u64> ) -> <Wrapping<u64> as BitXor<Wrapping<u64>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<u64>> for Wrapping<u64>

§

type Output = <Wrapping<u64> as BitXor<Wrapping<u64>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<u64> ) -> <Wrapping<u64> as BitXor<Wrapping<u64>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<u8>> for &Wrapping<u8>

§

type Output = <Wrapping<u8> as BitXor<Wrapping<u8>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<u8> ) -> <Wrapping<u8> as BitXor<Wrapping<u8>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<u8>> for Wrapping<u8>

§

type Output = <Wrapping<u8> as BitXor<Wrapping<u8>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<u8> ) -> <Wrapping<u8> as BitXor<Wrapping<u8>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<usize>> for &Wrapping<usize>

§

type Output = <Wrapping<usize> as BitXor<Wrapping<usize>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<usize> ) -> <Wrapping<usize> as BitXor<Wrapping<usize>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl BitXor<&Wrapping<usize>> for Wrapping<usize>

§

type Output = <Wrapping<usize> as BitXor<Wrapping<usize>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: &Wrapping<usize> ) -> <Wrapping<usize> as BitXor<Wrapping<usize>>>::Output

执行 ^ 操作。 Read more
1.14.0 · source§

impl<'a> BitXor<Wrapping<i128>> for &'a Wrapping<i128>

§

type Output = <Wrapping<i128> as BitXor<Wrapping<i128>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: Wrapping<i128> ) -> <Wrapping<i128> as BitXor<Wrapping<i128>>>::Output

执行 ^ 操作。 Read more
source§

impl BitXor<Wrapping<i128>> for Wrapping<i128>

§

type Output = Wrapping<i128>

应用 ^ 运算符后的结果类型。
source§

fn bitxor(self, other: Wrapping<i128>) -> Wrapping<i128>

执行 ^ 操作。 Read more
1.14.0 · source§

impl<'a> BitXor<Wrapping<i16>> for &'a Wrapping<i16>

§

type Output = <Wrapping<i16> as BitXor<Wrapping<i16>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: Wrapping<i16> ) -> <Wrapping<i16> as BitXor<Wrapping<i16>>>::Output

执行 ^ 操作。 Read more
source§

impl BitXor<Wrapping<i16>> for Wrapping<i16>

§

type Output = Wrapping<i16>

应用 ^ 运算符后的结果类型。
source§

fn bitxor(self, other: Wrapping<i16>) -> Wrapping<i16>

执行 ^ 操作。 Read more
1.14.0 · source§

impl<'a> BitXor<Wrapping<i32>> for &'a Wrapping<i32>

§

type Output = <Wrapping<i32> as BitXor<Wrapping<i32>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: Wrapping<i32> ) -> <Wrapping<i32> as BitXor<Wrapping<i32>>>::Output

执行 ^ 操作。 Read more
source§

impl BitXor<Wrapping<i32>> for Wrapping<i32>

§

type Output = Wrapping<i32>

应用 ^ 运算符后的结果类型。
source§

fn bitxor(self, other: Wrapping<i32>) -> Wrapping<i32>

执行 ^ 操作。 Read more
1.14.0 · source§

impl<'a> BitXor<Wrapping<i64>> for &'a Wrapping<i64>

§

type Output = <Wrapping<i64> as BitXor<Wrapping<i64>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: Wrapping<i64> ) -> <Wrapping<i64> as BitXor<Wrapping<i64>>>::Output

执行 ^ 操作。 Read more
source§

impl BitXor<Wrapping<i64>> for Wrapping<i64>

§

type Output = Wrapping<i64>

应用 ^ 运算符后的结果类型。
source§

fn bitxor(self, other: Wrapping<i64>) -> Wrapping<i64>

执行 ^ 操作。 Read more
1.14.0 · source§

impl<'a> BitXor<Wrapping<i8>> for &'a Wrapping<i8>

§

type Output = <Wrapping<i8> as BitXor<Wrapping<i8>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: Wrapping<i8> ) -> <Wrapping<i8> as BitXor<Wrapping<i8>>>::Output

执行 ^ 操作。 Read more
source§

impl BitXor<Wrapping<i8>> for Wrapping<i8>

§

type Output = Wrapping<i8>

应用 ^ 运算符后的结果类型。
source§

fn bitxor(self, other: Wrapping<i8>) -> Wrapping<i8>

执行 ^ 操作。 Read more
1.14.0 · source§

impl<'a> BitXor<Wrapping<isize>> for &'a Wrapping<isize>

§

type Output = <Wrapping<isize> as BitXor<Wrapping<isize>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: Wrapping<isize> ) -> <Wrapping<isize> as BitXor<Wrapping<isize>>>::Output

执行 ^ 操作。 Read more
source§

impl BitXor<Wrapping<isize>> for Wrapping<isize>

§

type Output = Wrapping<isize>

应用 ^ 运算符后的结果类型。
source§

fn bitxor(self, other: Wrapping<isize>) -> Wrapping<isize>

执行 ^ 操作。 Read more
1.14.0 · source§

impl<'a> BitXor<Wrapping<u128>> for &'a Wrapping<u128>

§

type Output = <Wrapping<u128> as BitXor<Wrapping<u128>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: Wrapping<u128> ) -> <Wrapping<u128> as BitXor<Wrapping<u128>>>::Output

执行 ^ 操作。 Read more
source§

impl BitXor<Wrapping<u128>> for Wrapping<u128>

§

type Output = Wrapping<u128>

应用 ^ 运算符后的结果类型。
source§

fn bitxor(self, other: Wrapping<u128>) -> Wrapping<u128>

执行 ^ 操作。 Read more
1.14.0 · source§

impl<'a> BitXor<Wrapping<u16>> for &'a Wrapping<u16>

§

type Output = <Wrapping<u16> as BitXor<Wrapping<u16>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: Wrapping<u16> ) -> <Wrapping<u16> as BitXor<Wrapping<u16>>>::Output

执行 ^ 操作。 Read more
source§

impl BitXor<Wrapping<u16>> for Wrapping<u16>

§

type Output = Wrapping<u16>

应用 ^ 运算符后的结果类型。
source§

fn bitxor(self, other: Wrapping<u16>) -> Wrapping<u16>

执行 ^ 操作。 Read more
1.14.0 · source§

impl<'a> BitXor<Wrapping<u32>> for &'a Wrapping<u32>

§

type Output = <Wrapping<u32> as BitXor<Wrapping<u32>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: Wrapping<u32> ) -> <Wrapping<u32> as BitXor<Wrapping<u32>>>::Output

执行 ^ 操作。 Read more
source§

impl BitXor<Wrapping<u32>> for Wrapping<u32>

§

type Output = Wrapping<u32>

应用 ^ 运算符后的结果类型。
source§

fn bitxor(self, other: Wrapping<u32>) -> Wrapping<u32>

执行 ^ 操作。 Read more
1.14.0 · source§

impl<'a> BitXor<Wrapping<u64>> for &'a Wrapping<u64>

§

type Output = <Wrapping<u64> as BitXor<Wrapping<u64>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: Wrapping<u64> ) -> <Wrapping<u64> as BitXor<Wrapping<u64>>>::Output

执行 ^ 操作。 Read more
source§

impl BitXor<Wrapping<u64>> for Wrapping<u64>

§

type Output = Wrapping<u64>

应用 ^ 运算符后的结果类型。
source§

fn bitxor(self, other: Wrapping<u64>) -> Wrapping<u64>

执行 ^ 操作。 Read more
1.14.0 · source§

impl<'a> BitXor<Wrapping<u8>> for &'a Wrapping<u8>

§

type Output = <Wrapping<u8> as BitXor<Wrapping<u8>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: Wrapping<u8> ) -> <Wrapping<u8> as BitXor<Wrapping<u8>>>::Output

执行 ^ 操作。 Read more
source§

impl BitXor<Wrapping<u8>> for Wrapping<u8>

§

type Output = Wrapping<u8>

应用 ^ 运算符后的结果类型。
source§

fn bitxor(self, other: Wrapping<u8>) -> Wrapping<u8>

执行 ^ 操作。 Read more
1.14.0 · source§

impl<'a> BitXor<Wrapping<usize>> for &'a Wrapping<usize>

§

type Output = <Wrapping<usize> as BitXor<Wrapping<usize>>>::Output

应用 ^ 运算符后的结果类型。
source§

fn bitxor( self, other: Wrapping<usize> ) -> <Wrapping<usize> as BitXor<Wrapping<usize>>>::Output

执行 ^ 操作。 Read more
source§

impl BitXor<Wrapping<usize>> for Wrapping<usize>

§

type Output = Wrapping<usize>

应用 ^ 运算符后的结果类型。
source§

fn bitxor(self, other: Wrapping<usize>) -> Wrapping<usize>

执行 ^ 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&Wrapping<i128>> for Wrapping<i128>

source§

fn bitxor_assign(&mut self, other: &Wrapping<i128>)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&Wrapping<i16>> for Wrapping<i16>

source§

fn bitxor_assign(&mut self, other: &Wrapping<i16>)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&Wrapping<i32>> for Wrapping<i32>

source§

fn bitxor_assign(&mut self, other: &Wrapping<i32>)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&Wrapping<i64>> for Wrapping<i64>

source§

fn bitxor_assign(&mut self, other: &Wrapping<i64>)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&Wrapping<i8>> for Wrapping<i8>

source§

fn bitxor_assign(&mut self, other: &Wrapping<i8>)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&Wrapping<isize>> for Wrapping<isize>

source§

fn bitxor_assign(&mut self, other: &Wrapping<isize>)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&Wrapping<u128>> for Wrapping<u128>

source§

fn bitxor_assign(&mut self, other: &Wrapping<u128>)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&Wrapping<u16>> for Wrapping<u16>

source§

fn bitxor_assign(&mut self, other: &Wrapping<u16>)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&Wrapping<u32>> for Wrapping<u32>

source§

fn bitxor_assign(&mut self, other: &Wrapping<u32>)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&Wrapping<u64>> for Wrapping<u64>

source§

fn bitxor_assign(&mut self, other: &Wrapping<u64>)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&Wrapping<u8>> for Wrapping<u8>

source§

fn bitxor_assign(&mut self, other: &Wrapping<u8>)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&Wrapping<usize>> for Wrapping<usize>

source§

fn bitxor_assign(&mut self, other: &Wrapping<usize>)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&i128> for Wrapping<i128>

source§

fn bitxor_assign(&mut self, other: &i128)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&i16> for Wrapping<i16>

source§

fn bitxor_assign(&mut self, other: &i16)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&i32> for Wrapping<i32>

source§

fn bitxor_assign(&mut self, other: &i32)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&i64> for Wrapping<i64>

source§

fn bitxor_assign(&mut self, other: &i64)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&i8> for Wrapping<i8>

source§

fn bitxor_assign(&mut self, other: &i8)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&isize> for Wrapping<isize>

source§

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

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&u128> for Wrapping<u128>

source§

fn bitxor_assign(&mut self, other: &u128)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&u16> for Wrapping<u16>

source§

fn bitxor_assign(&mut self, other: &u16)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&u32> for Wrapping<u32>

source§

fn bitxor_assign(&mut self, other: &u32)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&u64> for Wrapping<u64>

source§

fn bitxor_assign(&mut self, other: &u64)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&u8> for Wrapping<u8>

source§

fn bitxor_assign(&mut self, other: &u8)

执行 ^= 操作。 Read more
1.22.0 · source§

impl BitXorAssign<&usize> for Wrapping<usize>

source§

fn bitxor_assign(&mut self, other: &usize)

执行 ^= 操作。 Read more
1.8.0 · source§

impl BitXorAssign<Wrapping<i128>> for Wrapping<i128>

source§

fn bitxor_assign(&mut self, other: Wrapping<i128>)

执行 ^= 操作。 Read more
1.8.0 · source§

impl BitXorAssign<Wrapping<i16>> for Wrapping<i16>

source§

fn bitxor_assign(&mut self, other: Wrapping<i16>)

执行 ^= 操作。 Read more
1.8.0 · source§

impl BitXorAssign<Wrapping<i32>> for Wrapping<i32>

source§

fn bitxor_assign(&mut self, other: Wrapping<i32>)

执行 ^= 操作。 Read more
1.8.0 · source§

impl BitXorAssign<Wrapping<i64>> for Wrapping<i64>

source§

fn bitxor_assign(&mut self, other: Wrapping<i64>)

执行 ^= 操作。 Read more
1.8.0 · source§

impl BitXorAssign<Wrapping<i8>> for Wrapping<i8>

source§

fn bitxor_assign(&mut self, other: Wrapping<i8>)

执行 ^= 操作。 Read more
1.8.0 · source§

impl BitXorAssign<Wrapping<isize>> for Wrapping<isize>

source§

fn bitxor_assign(&mut self, other: Wrapping<isize>)

执行 ^= 操作。 Read more
1.8.0 · source§

impl BitXorAssign<Wrapping<u128>> for Wrapping<u128>

source§

fn bitxor_assign(&mut self, other: Wrapping<u128>)

执行 ^= 操作。 Read more
1.8.0 · source§

impl BitXorAssign<Wrapping<u16>> for Wrapping<u16>

source§

fn bitxor_assign(&mut self, other: Wrapping<u16>)

执行 ^= 操作。 Read more
1.8.0 · source§

impl BitXorAssign<Wrapping<u32>> for Wrapping<u32>

source§

fn bitxor_assign(&mut self, other: Wrapping<u32>)

执行 ^= 操作。 Read more
1.8.0 · source§

impl BitXorAssign<Wrapping<u64>> for Wrapping<u64>

source§

fn bitxor_assign(&mut self, other: Wrapping<u64>)

执行 ^= 操作。 Read more
1.8.0 · source§

impl BitXorAssign<Wrapping<u8>> for Wrapping<u8>

source§

fn bitxor_assign(&mut self, other: Wrapping<u8>)

执行 ^= 操作。 Read more
1.8.0 · source§

impl BitXorAssign<Wrapping<usize>> for Wrapping<usize>

source§

fn bitxor_assign(&mut self, other: Wrapping<usize>)

执行 ^= 操作。 Read more
1.60.0 · source§

impl BitXorAssign<i128> for Wrapping<i128>

source§

fn bitxor_assign(&mut self, other: i128)

执行 ^= 操作。 Read more
1.60.0 · source§

impl BitXorAssign<i16> for Wrapping<i16>

source§

fn bitxor_assign(&mut self, other: i16)

执行 ^= 操作。 Read more
1.60.0 · source§

impl BitXorAssign<i32> for Wrapping<i32>

source§

fn bitxor_assign(&mut self, other: i32)

执行 ^= 操作。 Read more
1.60.0 · source§

impl BitXorAssign<i64> for Wrapping<i64>

source§

fn bitxor_assign(&mut self, other: i64)

执行 ^= 操作。 Read more
1.60.0 · source§

impl BitXorAssign<i8> for Wrapping<i8>

source§

fn bitxor_assign(&mut self, other: i8)

执行 ^= 操作。 Read more
1.60.0 · source§

impl BitXorAssign<isize> for Wrapping<isize>

source§

fn bitxor_assign(&mut self, other: isize)

执行 ^= 操作。 Read more
1.60.0 · source§

impl BitXorAssign<u128> for Wrapping<u128>

source§

fn bitxor_assign(&mut self, other: u128)

执行 ^= 操作。 Read more
1.60.0 · source§

impl BitXorAssign<u16> for Wrapping<u16>

source§

fn bitxor_assign(&mut self, other: u16)

执行 ^= 操作。 Read more
1.60.0 · source§

impl BitXorAssign<u32> for Wrapping<u32>

source§

fn bitxor_assign(&mut self, other: u32)

执行 ^= 操作。 Read more
1.60.0 · source§

impl BitXorAssign<u64> for Wrapping<u64>

source§

fn bitxor_assign(&mut self, other: u64)

执行 ^= 操作。 Read more
1.60.0 · source§

impl BitXorAssign<u8> for Wrapping<u8>

source§

fn bitxor_assign(&mut self, other: u8)

执行 ^= 操作。 Read more
1.60.0 · source§

impl BitXorAssign<usize> for Wrapping<usize>

source§

fn bitxor_assign(&mut self, other: usize)

执行 ^= 操作。 Read more
source§

impl<T> Clone for Wrapping<T>where T: Clone,

source§

fn clone(&self) -> Wrapping<T>

返回值的副本。 Read more
source§

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

source 执行复制分配。 Read more
source§

impl<T> Debug for Wrapping<T>where T: Debug,

source§

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

使用给定的格式化程序格式化该值。 Read more
source§

impl<T> Default for Wrapping<T>where T: Default,

source§

fn default() -> Wrapping<T>

返回类型的 “默认值”。 Read more
1.10.0 · source§

impl<T> Display for Wrapping<T>where T: Display,

source§

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

使用给定的格式化程序格式化该值。 Read more
1.14.0 · source§

impl Div<&Wrapping<i128>> for &Wrapping<i128>

§

type Output = <Wrapping<i128> as Div<Wrapping<i128>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<i128> ) -> <Wrapping<i128> as Div<Wrapping<i128>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<i128>> for Wrapping<i128>

§

type Output = <Wrapping<i128> as Div<Wrapping<i128>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<i128> ) -> <Wrapping<i128> as Div<Wrapping<i128>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<i16>> for &Wrapping<i16>

§

type Output = <Wrapping<i16> as Div<Wrapping<i16>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<i16> ) -> <Wrapping<i16> as Div<Wrapping<i16>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<i16>> for Wrapping<i16>

§

type Output = <Wrapping<i16> as Div<Wrapping<i16>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<i16> ) -> <Wrapping<i16> as Div<Wrapping<i16>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<i32>> for &Wrapping<i32>

§

type Output = <Wrapping<i32> as Div<Wrapping<i32>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<i32> ) -> <Wrapping<i32> as Div<Wrapping<i32>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<i32>> for Wrapping<i32>

§

type Output = <Wrapping<i32> as Div<Wrapping<i32>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<i32> ) -> <Wrapping<i32> as Div<Wrapping<i32>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<i64>> for &Wrapping<i64>

§

type Output = <Wrapping<i64> as Div<Wrapping<i64>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<i64> ) -> <Wrapping<i64> as Div<Wrapping<i64>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<i64>> for Wrapping<i64>

§

type Output = <Wrapping<i64> as Div<Wrapping<i64>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<i64> ) -> <Wrapping<i64> as Div<Wrapping<i64>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<i8>> for &Wrapping<i8>

§

type Output = <Wrapping<i8> as Div<Wrapping<i8>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<i8> ) -> <Wrapping<i8> as Div<Wrapping<i8>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<i8>> for Wrapping<i8>

§

type Output = <Wrapping<i8> as Div<Wrapping<i8>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<i8> ) -> <Wrapping<i8> as Div<Wrapping<i8>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<isize>> for &Wrapping<isize>

§

type Output = <Wrapping<isize> as Div<Wrapping<isize>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<isize> ) -> <Wrapping<isize> as Div<Wrapping<isize>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<isize>> for Wrapping<isize>

§

type Output = <Wrapping<isize> as Div<Wrapping<isize>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<isize> ) -> <Wrapping<isize> as Div<Wrapping<isize>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<u128>> for &Wrapping<u128>

§

type Output = <Wrapping<u128> as Div<Wrapping<u128>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<u128> ) -> <Wrapping<u128> as Div<Wrapping<u128>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<u128>> for Wrapping<u128>

§

type Output = <Wrapping<u128> as Div<Wrapping<u128>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<u128> ) -> <Wrapping<u128> as Div<Wrapping<u128>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<u16>> for &Wrapping<u16>

§

type Output = <Wrapping<u16> as Div<Wrapping<u16>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<u16> ) -> <Wrapping<u16> as Div<Wrapping<u16>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<u16>> for Wrapping<u16>

§

type Output = <Wrapping<u16> as Div<Wrapping<u16>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<u16> ) -> <Wrapping<u16> as Div<Wrapping<u16>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<u32>> for &Wrapping<u32>

§

type Output = <Wrapping<u32> as Div<Wrapping<u32>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<u32> ) -> <Wrapping<u32> as Div<Wrapping<u32>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<u32>> for Wrapping<u32>

§

type Output = <Wrapping<u32> as Div<Wrapping<u32>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<u32> ) -> <Wrapping<u32> as Div<Wrapping<u32>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<u64>> for &Wrapping<u64>

§

type Output = <Wrapping<u64> as Div<Wrapping<u64>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<u64> ) -> <Wrapping<u64> as Div<Wrapping<u64>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<u64>> for Wrapping<u64>

§

type Output = <Wrapping<u64> as Div<Wrapping<u64>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<u64> ) -> <Wrapping<u64> as Div<Wrapping<u64>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<u8>> for &Wrapping<u8>

§

type Output = <Wrapping<u8> as Div<Wrapping<u8>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<u8> ) -> <Wrapping<u8> as Div<Wrapping<u8>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<u8>> for Wrapping<u8>

§

type Output = <Wrapping<u8> as Div<Wrapping<u8>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<u8> ) -> <Wrapping<u8> as Div<Wrapping<u8>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<usize>> for &Wrapping<usize>

§

type Output = <Wrapping<usize> as Div<Wrapping<usize>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<usize> ) -> <Wrapping<usize> as Div<Wrapping<usize>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl Div<&Wrapping<usize>> for Wrapping<usize>

§

type Output = <Wrapping<usize> as Div<Wrapping<usize>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: &Wrapping<usize> ) -> <Wrapping<usize> as Div<Wrapping<usize>>>::Output

执行 / 操作。 Read more
1.14.0 · source§

impl<'a> Div<Wrapping<i128>> for &'a Wrapping<i128>

§

type Output = <Wrapping<i128> as Div<Wrapping<i128>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: Wrapping<i128> ) -> <Wrapping<i128> as Div<Wrapping<i128>>>::Output

执行 / 操作。 Read more
1.3.0 · source§

impl Div<Wrapping<i128>> for Wrapping<i128>

§

type Output = Wrapping<i128>

应用 / 运算符后的结果类型。
source§

fn div(self, other: Wrapping<i128>) -> Wrapping<i128>

执行 / 操作。 Read more
1.14.0 · source§

impl<'a> Div<Wrapping<i16>> for &'a Wrapping<i16>

§

type Output = <Wrapping<i16> as Div<Wrapping<i16>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: Wrapping<i16> ) -> <Wrapping<i16> as Div<Wrapping<i16>>>::Output

执行 / 操作。 Read more
1.3.0 · source§

impl Div<Wrapping<i16>> for Wrapping<i16>

§

type Output = Wrapping<i16>

应用 / 运算符后的结果类型。
source§

fn div(self, other: Wrapping<i16>) -> Wrapping<i16>

执行 / 操作。 Read more
1.14.0 · source§

impl<'a> Div<Wrapping<i32>> for &'a Wrapping<i32>

§

type Output = <Wrapping<i32> as Div<Wrapping<i32>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: Wrapping<i32> ) -> <Wrapping<i32> as Div<Wrapping<i32>>>::Output

执行 / 操作。 Read more
1.3.0 · source§

impl Div<Wrapping<i32>> for Wrapping<i32>

§

type Output = Wrapping<i32>

应用 / 运算符后的结果类型。
source§

fn div(self, other: Wrapping<i32>) -> Wrapping<i32>

执行 / 操作。 Read more
1.14.0 · source§

impl<'a> Div<Wrapping<i64>> for &'a Wrapping<i64>

§

type Output = <Wrapping<i64> as Div<Wrapping<i64>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: Wrapping<i64> ) -> <Wrapping<i64> as Div<Wrapping<i64>>>::Output

执行 / 操作。 Read more
1.3.0 · source§

impl Div<Wrapping<i64>> for Wrapping<i64>

§

type Output = Wrapping<i64>

应用 / 运算符后的结果类型。
source§

fn div(self, other: Wrapping<i64>) -> Wrapping<i64>

执行 / 操作。 Read more
1.14.0 · source§

impl<'a> Div<Wrapping<i8>> for &'a Wrapping<i8>

§

type Output = <Wrapping<i8> as Div<Wrapping<i8>>>::Output

应用 / 运算符后的结果类型。
source§

fn div(self, other: Wrapping<i8>) -> <Wrapping<i8> as Div<Wrapping<i8>>>::Output

执行 / 操作。 Read more
1.3.0 · source§

impl Div<Wrapping<i8>> for Wrapping<i8>

§

type Output = Wrapping<i8>

应用 / 运算符后的结果类型。
source§

fn div(self, other: Wrapping<i8>) -> Wrapping<i8>

执行 / 操作。 Read more
1.14.0 · source§

impl<'a> Div<Wrapping<isize>> for &'a Wrapping<isize>

§

type Output = <Wrapping<isize> as Div<Wrapping<isize>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: Wrapping<isize> ) -> <Wrapping<isize> as Div<Wrapping<isize>>>::Output

执行 / 操作。 Read more
1.3.0 · source§

impl Div<Wrapping<isize>> for Wrapping<isize>

§

type Output = Wrapping<isize>

应用 / 运算符后的结果类型。
source§

fn div(self, other: Wrapping<isize>) -> Wrapping<isize>

执行 / 操作。 Read more
1.14.0 · source§

impl<'a> Div<Wrapping<u128>> for &'a Wrapping<u128>

§

type Output = <Wrapping<u128> as Div<Wrapping<u128>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: Wrapping<u128> ) -> <Wrapping<u128> as Div<Wrapping<u128>>>::Output

执行 / 操作。 Read more
1.3.0 · source§

impl Div<Wrapping<u128>> for Wrapping<u128>

§

type Output = Wrapping<u128>

应用 / 运算符后的结果类型。
source§

fn div(self, other: Wrapping<u128>) -> Wrapping<u128>

执行 / 操作。 Read more
1.14.0 · source§

impl<'a> Div<Wrapping<u16>> for &'a Wrapping<u16>

§

type Output = <Wrapping<u16> as Div<Wrapping<u16>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: Wrapping<u16> ) -> <Wrapping<u16> as Div<Wrapping<u16>>>::Output

执行 / 操作。 Read more
1.3.0 · source§

impl Div<Wrapping<u16>> for Wrapping<u16>

§

type Output = Wrapping<u16>

应用 / 运算符后的结果类型。
source§

fn div(self, other: Wrapping<u16>) -> Wrapping<u16>

执行 / 操作。 Read more
1.14.0 · source§

impl<'a> Div<Wrapping<u32>> for &'a Wrapping<u32>

§

type Output = <Wrapping<u32> as Div<Wrapping<u32>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: Wrapping<u32> ) -> <Wrapping<u32> as Div<Wrapping<u32>>>::Output

执行 / 操作。 Read more
1.3.0 · source§

impl Div<Wrapping<u32>> for Wrapping<u32>

§

type Output = Wrapping<u32>

应用 / 运算符后的结果类型。
source§

fn div(self, other: Wrapping<u32>) -> Wrapping<u32>

执行 / 操作。 Read more
1.14.0 · source§

impl<'a> Div<Wrapping<u64>> for &'a Wrapping<u64>

§

type Output = <Wrapping<u64> as Div<Wrapping<u64>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: Wrapping<u64> ) -> <Wrapping<u64> as Div<Wrapping<u64>>>::Output

执行 / 操作。 Read more
1.3.0 · source§

impl Div<Wrapping<u64>> for Wrapping<u64>

§

type Output = Wrapping<u64>

应用 / 运算符后的结果类型。
source§

fn div(self, other: Wrapping<u64>) -> Wrapping<u64>

执行 / 操作。 Read more
1.14.0 · source§

impl<'a> Div<Wrapping<u8>> for &'a Wrapping<u8>

§

type Output = <Wrapping<u8> as Div<Wrapping<u8>>>::Output

应用 / 运算符后的结果类型。
source§

fn div(self, other: Wrapping<u8>) -> <Wrapping<u8> as Div<Wrapping<u8>>>::Output

执行 / 操作。 Read more
1.3.0 · source§

impl Div<Wrapping<u8>> for Wrapping<u8>

§

type Output = Wrapping<u8>

应用 / 运算符后的结果类型。
source§

fn div(self, other: Wrapping<u8>) -> Wrapping<u8>

执行 / 操作。 Read more
1.14.0 · source§

impl<'a> Div<Wrapping<usize>> for &'a Wrapping<usize>

§

type Output = <Wrapping<usize> as Div<Wrapping<usize>>>::Output

应用 / 运算符后的结果类型。
source§

fn div( self, other: Wrapping<usize> ) -> <Wrapping<usize> as Div<Wrapping<usize>>>::Output

执行 / 操作。 Read more
1.3.0 · source§

impl Div<Wrapping<usize>> for Wrapping<usize>

§

type Output = Wrapping<usize>

应用 / 运算符后的结果类型。
source§

fn div(self, other: Wrapping<usize>) -> Wrapping<usize>

执行 / 操作。 Read more
1.22.0 · source§

impl DivAssign<&Wrapping<i128>> for Wrapping<i128>

source§

fn div_assign(&mut self, other: &Wrapping<i128>)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&Wrapping<i16>> for Wrapping<i16>

source§

fn div_assign(&mut self, other: &Wrapping<i16>)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&Wrapping<i32>> for Wrapping<i32>

source§

fn div_assign(&mut self, other: &Wrapping<i32>)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&Wrapping<i64>> for Wrapping<i64>

source§

fn div_assign(&mut self, other: &Wrapping<i64>)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&Wrapping<i8>> for Wrapping<i8>

source§

fn div_assign(&mut self, other: &Wrapping<i8>)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&Wrapping<isize>> for Wrapping<isize>

source§

fn div_assign(&mut self, other: &Wrapping<isize>)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&Wrapping<u128>> for Wrapping<u128>

source§

fn div_assign(&mut self, other: &Wrapping<u128>)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&Wrapping<u16>> for Wrapping<u16>

source§

fn div_assign(&mut self, other: &Wrapping<u16>)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&Wrapping<u32>> for Wrapping<u32>

source§

fn div_assign(&mut self, other: &Wrapping<u32>)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&Wrapping<u64>> for Wrapping<u64>

source§

fn div_assign(&mut self, other: &Wrapping<u64>)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&Wrapping<u8>> for Wrapping<u8>

source§

fn div_assign(&mut self, other: &Wrapping<u8>)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&Wrapping<usize>> for Wrapping<usize>

source§

fn div_assign(&mut self, other: &Wrapping<usize>)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&i128> for Wrapping<i128>

source§

fn div_assign(&mut self, other: &i128)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&i16> for Wrapping<i16>

source§

fn div_assign(&mut self, other: &i16)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&i32> for Wrapping<i32>

source§

fn div_assign(&mut self, other: &i32)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&i64> for Wrapping<i64>

source§

fn div_assign(&mut self, other: &i64)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&i8> for Wrapping<i8>

source§

fn div_assign(&mut self, other: &i8)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&isize> for Wrapping<isize>

source§

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

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&u128> for Wrapping<u128>

source§

fn div_assign(&mut self, other: &u128)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&u16> for Wrapping<u16>

source§

fn div_assign(&mut self, other: &u16)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&u32> for Wrapping<u32>

source§

fn div_assign(&mut self, other: &u32)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&u64> for Wrapping<u64>

source§

fn div_assign(&mut self, other: &u64)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&u8> for Wrapping<u8>

source§

fn div_assign(&mut self, other: &u8)

执行 /= 操作。 Read more
1.22.0 · source§

impl DivAssign<&usize> for Wrapping<usize>

source§

fn div_assign(&mut self, other: &usize)

执行 /= 操作。 Read more
1.8.0 · source§

impl DivAssign<Wrapping<i128>> for Wrapping<i128>

source§

fn div_assign(&mut self, other: Wrapping<i128>)

执行 /= 操作。 Read more
1.8.0 · source§

impl DivAssign<Wrapping<i16>> for Wrapping<i16>

source§

fn div_assign(&mut self, other: Wrapping<i16>)

执行 /= 操作。 Read more
1.8.0 · source§

impl DivAssign<Wrapping<i32>> for Wrapping<i32>

source§

fn div_assign(&mut self, other: Wrapping<i32>)

执行 /= 操作。 Read more
1.8.0 · source§

impl DivAssign<Wrapping<i64>> for Wrapping<i64>

source§

fn div_assign(&mut self, other: Wrapping<i64>)

执行 /= 操作。 Read more
1.8.0 · source§

impl DivAssign<Wrapping<i8>> for Wrapping<i8>

source§

fn div_assign(&mut self, other: Wrapping<i8>)

执行 /= 操作。 Read more
1.8.0 · source§

impl DivAssign<Wrapping<isize>> for Wrapping<isize>

source§

fn div_assign(&mut self, other: Wrapping<isize>)

执行 /= 操作。 Read more
1.8.0 · source§

impl DivAssign<Wrapping<u128>> for Wrapping<u128>

source§

fn div_assign(&mut self, other: Wrapping<u128>)

执行 /= 操作。 Read more
1.8.0 · source§

impl DivAssign<Wrapping<u16>> for Wrapping<u16>

source§

fn div_assign(&mut self, other: Wrapping<u16>)

执行 /= 操作。 Read more
1.8.0 · source§

impl DivAssign<Wrapping<u32>> for Wrapping<u32>

source§

fn div_assign(&mut self, other: Wrapping<u32>)

执行 /= 操作。 Read more
1.8.0 · source§

impl DivAssign<Wrapping<u64>> for Wrapping<u64>

source§

fn div_assign(&mut self, other: Wrapping<u64>)

执行 /= 操作。 Read more
1.8.0 · source§

impl DivAssign<Wrapping<u8>> for Wrapping<u8>

source§

fn div_assign(&mut self, other: Wrapping<u8>)

执行 /= 操作。 Read more
1.8.0 · source§

impl DivAssign<Wrapping<usize>> for Wrapping<usize>

source§

fn div_assign(&mut self, other: Wrapping<usize>)

执行 /= 操作。 Read more
1.60.0 · source§

impl DivAssign<i128> for Wrapping<i128>

source§

fn div_assign(&mut self, other: i128)

执行 /= 操作。 Read more
1.60.0 · source§

impl DivAssign<i16> for Wrapping<i16>

source§

fn div_assign(&mut self, other: i16)

执行 /= 操作。 Read more
1.60.0 · source§

impl DivAssign<i32> for Wrapping<i32>

source§

fn div_assign(&mut self, other: i32)

执行 /= 操作。 Read more
1.60.0 · source§

impl DivAssign<i64> for Wrapping<i64>

source§

fn div_assign(&mut self, other: i64)

执行 /= 操作。 Read more
1.60.0 · source§

impl DivAssign<i8> for Wrapping<i8>

source§

fn div_assign(&mut self, other: i8)

执行 /= 操作。 Read more
1.60.0 · source§

impl DivAssign<isize> for Wrapping<isize>

source§

fn div_assign(&mut self, other: isize)

执行 /= 操作。 Read more
1.60.0 · source§

impl DivAssign<u128> for Wrapping<u128>

source§

fn div_assign(&mut self, other: u128)

执行 /= 操作。 Read more
1.60.0 · source§

impl DivAssign<u16> for Wrapping<u16>

source§

fn div_assign(&mut self, other: u16)

执行 /= 操作。 Read more
1.60.0 · source§

impl DivAssign<u32> for Wrapping<u32>

source§

fn div_assign(&mut self, other: u32)

执行 /= 操作。 Read more
1.60.0 · source§

impl DivAssign<u64> for Wrapping<u64>

source§

fn div_assign(&mut self, other: u64)

执行 /= 操作。 Read more
1.60.0 · source§

impl DivAssign<u8> for Wrapping<u8>

source§

fn div_assign(&mut self, other: u8)

执行 /= 操作。 Read more
1.60.0 · source§

impl DivAssign<usize> for Wrapping<usize>

source§

fn div_assign(&mut self, other: usize)

执行 /= 操作。 Read more
source§

impl<T> Hash for Wrapping<T>where T: Hash,

source§

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

将该值输入给定的 HasherRead more
1.3.0 · source§

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

将这种类型的切片送入给定的 Hasher 中。 Read more
1.11.0 · source§

impl<T> LowerHex for Wrapping<T>where T: LowerHex,

source§

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

使用给定的格式化程序格式化该值。
1.14.0 · source§

impl Mul<&Wrapping<i128>> for &Wrapping<i128>

§

type Output = <Wrapping<i128> as Mul<Wrapping<i128>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<i128> ) -> <Wrapping<i128> as Mul<Wrapping<i128>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<i128>> for Wrapping<i128>

§

type Output = <Wrapping<i128> as Mul<Wrapping<i128>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<i128> ) -> <Wrapping<i128> as Mul<Wrapping<i128>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<i16>> for &Wrapping<i16>

§

type Output = <Wrapping<i16> as Mul<Wrapping<i16>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<i16> ) -> <Wrapping<i16> as Mul<Wrapping<i16>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<i16>> for Wrapping<i16>

§

type Output = <Wrapping<i16> as Mul<Wrapping<i16>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<i16> ) -> <Wrapping<i16> as Mul<Wrapping<i16>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<i32>> for &Wrapping<i32>

§

type Output = <Wrapping<i32> as Mul<Wrapping<i32>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<i32> ) -> <Wrapping<i32> as Mul<Wrapping<i32>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<i32>> for Wrapping<i32>

§

type Output = <Wrapping<i32> as Mul<Wrapping<i32>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<i32> ) -> <Wrapping<i32> as Mul<Wrapping<i32>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<i64>> for &Wrapping<i64>

§

type Output = <Wrapping<i64> as Mul<Wrapping<i64>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<i64> ) -> <Wrapping<i64> as Mul<Wrapping<i64>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<i64>> for Wrapping<i64>

§

type Output = <Wrapping<i64> as Mul<Wrapping<i64>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<i64> ) -> <Wrapping<i64> as Mul<Wrapping<i64>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<i8>> for &Wrapping<i8>

§

type Output = <Wrapping<i8> as Mul<Wrapping<i8>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<i8> ) -> <Wrapping<i8> as Mul<Wrapping<i8>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<i8>> for Wrapping<i8>

§

type Output = <Wrapping<i8> as Mul<Wrapping<i8>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<i8> ) -> <Wrapping<i8> as Mul<Wrapping<i8>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<isize>> for &Wrapping<isize>

§

type Output = <Wrapping<isize> as Mul<Wrapping<isize>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<isize> ) -> <Wrapping<isize> as Mul<Wrapping<isize>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<isize>> for Wrapping<isize>

§

type Output = <Wrapping<isize> as Mul<Wrapping<isize>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<isize> ) -> <Wrapping<isize> as Mul<Wrapping<isize>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<u128>> for &Wrapping<u128>

§

type Output = <Wrapping<u128> as Mul<Wrapping<u128>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<u128> ) -> <Wrapping<u128> as Mul<Wrapping<u128>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<u128>> for Wrapping<u128>

§

type Output = <Wrapping<u128> as Mul<Wrapping<u128>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<u128> ) -> <Wrapping<u128> as Mul<Wrapping<u128>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<u16>> for &Wrapping<u16>

§

type Output = <Wrapping<u16> as Mul<Wrapping<u16>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<u16> ) -> <Wrapping<u16> as Mul<Wrapping<u16>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<u16>> for Wrapping<u16>

§

type Output = <Wrapping<u16> as Mul<Wrapping<u16>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<u16> ) -> <Wrapping<u16> as Mul<Wrapping<u16>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<u32>> for &Wrapping<u32>

§

type Output = <Wrapping<u32> as Mul<Wrapping<u32>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<u32> ) -> <Wrapping<u32> as Mul<Wrapping<u32>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<u32>> for Wrapping<u32>

§

type Output = <Wrapping<u32> as Mul<Wrapping<u32>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<u32> ) -> <Wrapping<u32> as Mul<Wrapping<u32>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<u64>> for &Wrapping<u64>

§

type Output = <Wrapping<u64> as Mul<Wrapping<u64>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<u64> ) -> <Wrapping<u64> as Mul<Wrapping<u64>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<u64>> for Wrapping<u64>

§

type Output = <Wrapping<u64> as Mul<Wrapping<u64>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<u64> ) -> <Wrapping<u64> as Mul<Wrapping<u64>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<u8>> for &Wrapping<u8>

§

type Output = <Wrapping<u8> as Mul<Wrapping<u8>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<u8> ) -> <Wrapping<u8> as Mul<Wrapping<u8>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<u8>> for Wrapping<u8>

§

type Output = <Wrapping<u8> as Mul<Wrapping<u8>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<u8> ) -> <Wrapping<u8> as Mul<Wrapping<u8>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<usize>> for &Wrapping<usize>

§

type Output = <Wrapping<usize> as Mul<Wrapping<usize>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<usize> ) -> <Wrapping<usize> as Mul<Wrapping<usize>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl Mul<&Wrapping<usize>> for Wrapping<usize>

§

type Output = <Wrapping<usize> as Mul<Wrapping<usize>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: &Wrapping<usize> ) -> <Wrapping<usize> as Mul<Wrapping<usize>>>::Output

执行 * 操作。 Read more
1.14.0 · source§

impl<'a> Mul<Wrapping<i128>> for &'a Wrapping<i128>

§

type Output = <Wrapping<i128> as Mul<Wrapping<i128>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: Wrapping<i128> ) -> <Wrapping<i128> as Mul<Wrapping<i128>>>::Output

执行 * 操作。 Read more
source§

impl Mul<Wrapping<i128>> for Wrapping<i128>

§

type Output = Wrapping<i128>

应用 * 运算符后的结果类型。
source§

fn mul(self, other: Wrapping<i128>) -> Wrapping<i128>

执行 * 操作。 Read more
1.14.0 · source§

impl<'a> Mul<Wrapping<i16>> for &'a Wrapping<i16>

§

type Output = <Wrapping<i16> as Mul<Wrapping<i16>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: Wrapping<i16> ) -> <Wrapping<i16> as Mul<Wrapping<i16>>>::Output

执行 * 操作。 Read more
source§

impl Mul<Wrapping<i16>> for Wrapping<i16>

§

type Output = Wrapping<i16>

应用 * 运算符后的结果类型。
source§

fn mul(self, other: Wrapping<i16>) -> Wrapping<i16>

执行 * 操作。 Read more
1.14.0 · source§

impl<'a> Mul<Wrapping<i32>> for &'a Wrapping<i32>

§

type Output = <Wrapping<i32> as Mul<Wrapping<i32>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: Wrapping<i32> ) -> <Wrapping<i32> as Mul<Wrapping<i32>>>::Output

执行 * 操作。 Read more
source§

impl Mul<Wrapping<i32>> for Wrapping<i32>

§

type Output = Wrapping<i32>

应用 * 运算符后的结果类型。
source§

fn mul(self, other: Wrapping<i32>) -> Wrapping<i32>

执行 * 操作。 Read more
1.14.0 · source§

impl<'a> Mul<Wrapping<i64>> for &'a Wrapping<i64>

§

type Output = <Wrapping<i64> as Mul<Wrapping<i64>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: Wrapping<i64> ) -> <Wrapping<i64> as Mul<Wrapping<i64>>>::Output

执行 * 操作。 Read more
source§

impl Mul<Wrapping<i64>> for Wrapping<i64>

§

type Output = Wrapping<i64>

应用 * 运算符后的结果类型。
source§

fn mul(self, other: Wrapping<i64>) -> Wrapping<i64>

执行 * 操作。 Read more
1.14.0 · source§

impl<'a> Mul<Wrapping<i8>> for &'a Wrapping<i8>

§

type Output = <Wrapping<i8> as Mul<Wrapping<i8>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul(self, other: Wrapping<i8>) -> <Wrapping<i8> as Mul<Wrapping<i8>>>::Output

执行 * 操作。 Read more
source§

impl Mul<Wrapping<i8>> for Wrapping<i8>

§

type Output = Wrapping<i8>

应用 * 运算符后的结果类型。
source§

fn mul(self, other: Wrapping<i8>) -> Wrapping<i8>

执行 * 操作。 Read more
1.14.0 · source§

impl<'a> Mul<Wrapping<isize>> for &'a Wrapping<isize>

§

type Output = <Wrapping<isize> as Mul<Wrapping<isize>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: Wrapping<isize> ) -> <Wrapping<isize> as Mul<Wrapping<isize>>>::Output

执行 * 操作。 Read more
source§

impl Mul<Wrapping<isize>> for Wrapping<isize>

§

type Output = Wrapping<isize>

应用 * 运算符后的结果类型。
source§

fn mul(self, other: Wrapping<isize>) -> Wrapping<isize>

执行 * 操作。 Read more
1.14.0 · source§

impl<'a> Mul<Wrapping<u128>> for &'a Wrapping<u128>

§

type Output = <Wrapping<u128> as Mul<Wrapping<u128>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: Wrapping<u128> ) -> <Wrapping<u128> as Mul<Wrapping<u128>>>::Output

执行 * 操作。 Read more
source§

impl Mul<Wrapping<u128>> for Wrapping<u128>

§

type Output = Wrapping<u128>

应用 * 运算符后的结果类型。
source§

fn mul(self, other: Wrapping<u128>) -> Wrapping<u128>

执行 * 操作。 Read more
1.14.0 · source§

impl<'a> Mul<Wrapping<u16>> for &'a Wrapping<u16>

§

type Output = <Wrapping<u16> as Mul<Wrapping<u16>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: Wrapping<u16> ) -> <Wrapping<u16> as Mul<Wrapping<u16>>>::Output

执行 * 操作。 Read more
source§

impl Mul<Wrapping<u16>> for Wrapping<u16>

§

type Output = Wrapping<u16>

应用 * 运算符后的结果类型。
source§

fn mul(self, other: Wrapping<u16>) -> Wrapping<u16>

执行 * 操作。 Read more
1.14.0 · source§

impl<'a> Mul<Wrapping<u32>> for &'a Wrapping<u32>

§

type Output = <Wrapping<u32> as Mul<Wrapping<u32>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: Wrapping<u32> ) -> <Wrapping<u32> as Mul<Wrapping<u32>>>::Output

执行 * 操作。 Read more
source§

impl Mul<Wrapping<u32>> for Wrapping<u32>

§

type Output = Wrapping<u32>

应用 * 运算符后的结果类型。
source§

fn mul(self, other: Wrapping<u32>) -> Wrapping<u32>

执行 * 操作。 Read more
1.14.0 · source§

impl<'a> Mul<Wrapping<u64>> for &'a Wrapping<u64>

§

type Output = <Wrapping<u64> as Mul<Wrapping<u64>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: Wrapping<u64> ) -> <Wrapping<u64> as Mul<Wrapping<u64>>>::Output

执行 * 操作。 Read more
source§

impl Mul<Wrapping<u64>> for Wrapping<u64>

§

type Output = Wrapping<u64>

应用 * 运算符后的结果类型。
source§

fn mul(self, other: Wrapping<u64>) -> Wrapping<u64>

执行 * 操作。 Read more
1.14.0 · source§

impl<'a> Mul<Wrapping<u8>> for &'a Wrapping<u8>

§

type Output = <Wrapping<u8> as Mul<Wrapping<u8>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul(self, other: Wrapping<u8>) -> <Wrapping<u8> as Mul<Wrapping<u8>>>::Output

执行 * 操作。 Read more
source§

impl Mul<Wrapping<u8>> for Wrapping<u8>

§

type Output = Wrapping<u8>

应用 * 运算符后的结果类型。
source§

fn mul(self, other: Wrapping<u8>) -> Wrapping<u8>

执行 * 操作。 Read more
1.14.0 · source§

impl<'a> Mul<Wrapping<usize>> for &'a Wrapping<usize>

§

type Output = <Wrapping<usize> as Mul<Wrapping<usize>>>::Output

应用 * 运算符后的结果类型。
source§

fn mul( self, other: Wrapping<usize> ) -> <Wrapping<usize> as Mul<Wrapping<usize>>>::Output

执行 * 操作。 Read more
source§

impl Mul<Wrapping<usize>> for Wrapping<usize>

§

type Output = Wrapping<usize>

应用 * 运算符后的结果类型。
source§

fn mul(self, other: Wrapping<usize>) -> Wrapping<usize>

执行 * 操作。 Read more
1.22.0 · source§

impl MulAssign<&Wrapping<i128>> for Wrapping<i128>

source§

fn mul_assign(&mut self, other: &Wrapping<i128>)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&Wrapping<i16>> for Wrapping<i16>

source§

fn mul_assign(&mut self, other: &Wrapping<i16>)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&Wrapping<i32>> for Wrapping<i32>

source§

fn mul_assign(&mut self, other: &Wrapping<i32>)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&Wrapping<i64>> for Wrapping<i64>

source§

fn mul_assign(&mut self, other: &Wrapping<i64>)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&Wrapping<i8>> for Wrapping<i8>

source§

fn mul_assign(&mut self, other: &Wrapping<i8>)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&Wrapping<isize>> for Wrapping<isize>

source§

fn mul_assign(&mut self, other: &Wrapping<isize>)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&Wrapping<u128>> for Wrapping<u128>

source§

fn mul_assign(&mut self, other: &Wrapping<u128>)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&Wrapping<u16>> for Wrapping<u16>

source§

fn mul_assign(&mut self, other: &Wrapping<u16>)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&Wrapping<u32>> for Wrapping<u32>

source§

fn mul_assign(&mut self, other: &Wrapping<u32>)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&Wrapping<u64>> for Wrapping<u64>

source§

fn mul_assign(&mut self, other: &Wrapping<u64>)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&Wrapping<u8>> for Wrapping<u8>

source§

fn mul_assign(&mut self, other: &Wrapping<u8>)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&Wrapping<usize>> for Wrapping<usize>

source§

fn mul_assign(&mut self, other: &Wrapping<usize>)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&i128> for Wrapping<i128>

source§

fn mul_assign(&mut self, other: &i128)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&i16> for Wrapping<i16>

source§

fn mul_assign(&mut self, other: &i16)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&i32> for Wrapping<i32>

source§

fn mul_assign(&mut self, other: &i32)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&i64> for Wrapping<i64>

source§

fn mul_assign(&mut self, other: &i64)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&i8> for Wrapping<i8>

source§

fn mul_assign(&mut self, other: &i8)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&isize> for Wrapping<isize>

source§

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

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&u128> for Wrapping<u128>

source§

fn mul_assign(&mut self, other: &u128)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&u16> for Wrapping<u16>

source§

fn mul_assign(&mut self, other: &u16)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&u32> for Wrapping<u32>

source§

fn mul_assign(&mut self, other: &u32)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&u64> for Wrapping<u64>

source§

fn mul_assign(&mut self, other: &u64)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&u8> for Wrapping<u8>

source§

fn mul_assign(&mut self, other: &u8)

执行 *= 操作。 Read more
1.22.0 · source§

impl MulAssign<&usize> for Wrapping<usize>

source§

fn mul_assign(&mut self, other: &usize)

执行 *= 操作。 Read more
1.8.0 · source§

impl MulAssign<Wrapping<i128>> for Wrapping<i128>

source§

fn mul_assign(&mut self, other: Wrapping<i128>)

执行 *= 操作。 Read more
1.8.0 · source§

impl MulAssign<Wrapping<i16>> for Wrapping<i16>

source§

fn mul_assign(&mut self, other: Wrapping<i16>)

执行 *= 操作。 Read more
1.8.0 · source§

impl MulAssign<Wrapping<i32>> for Wrapping<i32>

source§

fn mul_assign(&mut self, other: Wrapping<i32>)

执行 *= 操作。 Read more
1.8.0 · source§

impl MulAssign<Wrapping<i64>> for Wrapping<i64>

source§

fn mul_assign(&mut self, other: Wrapping<i64>)

执行 *= 操作。 Read more
1.8.0 · source§

impl MulAssign<Wrapping<i8>> for Wrapping<i8>

source§

fn mul_assign(&mut self, other: Wrapping<i8>)

执行 *= 操作。 Read more
1.8.0 · source§

impl MulAssign<Wrapping<isize>> for Wrapping<isize>

source§

fn mul_assign(&mut self, other: Wrapping<isize>)

执行 *= 操作。 Read more
1.8.0 · source§

impl MulAssign<Wrapping<u128>> for Wrapping<u128>

source§

fn mul_assign(&mut self, other: Wrapping<u128>)

执行 *= 操作。 Read more
1.8.0 · source§

impl MulAssign<Wrapping<u16>> for Wrapping<u16>

source§

fn mul_assign(&mut self, other: Wrapping<u16>)

执行 *= 操作。 Read more
1.8.0 · source§

impl MulAssign<Wrapping<u32>> for Wrapping<u32>

source§

fn mul_assign(&mut self, other: Wrapping<u32>)

执行 *= 操作。 Read more
1.8.0 · source§

impl MulAssign<Wrapping<u64>> for Wrapping<u64>

source§

fn mul_assign(&mut self, other: Wrapping<u64>)

执行 *= 操作。 Read more
1.8.0 · source§

impl MulAssign<Wrapping<u8>> for Wrapping<u8>

source§

fn mul_assign(&mut self, other: Wrapping<u8>)

执行 *= 操作。 Read more
1.8.0 · source§

impl MulAssign<Wrapping<usize>> for Wrapping<usize>

source§

fn mul_assign(&mut self, other: Wrapping<usize>)

执行 *= 操作。 Read more
1.60.0 · source§

impl MulAssign<i128> for Wrapping<i128>

source§

fn mul_assign(&mut self, other: i128)

执行 *= 操作。 Read more
1.60.0 · source§

impl MulAssign<i16> for Wrapping<i16>

source§

fn mul_assign(&mut self, other: i16)

执行 *= 操作。 Read more
1.60.0 · source§

impl MulAssign<i32> for Wrapping<i32>

source§

fn mul_assign(&mut self, other: i32)

执行 *= 操作。 Read more
1.60.0 · source§

impl MulAssign<i64> for Wrapping<i64>

source§

fn mul_assign(&mut self, other: i64)

执行 *= 操作。 Read more
1.60.0 · source§

impl MulAssign<i8> for Wrapping<i8>

source§

fn mul_assign(&mut self, other: i8)

执行 *= 操作。 Read more
1.60.0 · source§

impl MulAssign<isize> for Wrapping<isize>

source§

fn mul_assign(&mut self, other: isize)

执行 *= 操作。 Read more
1.60.0 · source§

impl MulAssign<u128> for Wrapping<u128>

source§

fn mul_assign(&mut self, other: u128)

执行 *= 操作。 Read more
1.60.0 · source§

impl MulAssign<u16> for Wrapping<u16>

source§

fn mul_assign(&mut self, other: u16)

执行 *= 操作。 Read more
1.60.0 · source§

impl MulAssign<u32> for Wrapping<u32>

source§

fn mul_assign(&mut self, other: u32)

执行 *= 操作。 Read more
1.60.0 · source§

impl MulAssign<u64> for Wrapping<u64>

source§

fn mul_assign(&mut self, other: u64)

执行 *= 操作。 Read more
1.60.0 · source§

impl MulAssign<u8> for Wrapping<u8>

source§

fn mul_assign(&mut self, other: u8)

执行 *= 操作。 Read more
1.60.0 · source§

impl MulAssign<usize> for Wrapping<usize>

source§

fn mul_assign(&mut self, other: usize)

执行 *= 操作。 Read more
1.14.0 · source§

impl Neg for &Wrapping<i128>

§

type Output = <Wrapping<i128> as Neg>::Output

应用 - 运算符后的结果类型。
source§

fn neg(self) -> <Wrapping<i128> as Neg>::Output

执行一元 - 运算。 Read more
1.14.0 · source§

impl Neg for &Wrapping<i16>

§

type Output = <Wrapping<i16> as Neg>::Output

应用 - 运算符后的结果类型。
source§

fn neg(self) -> <Wrapping<i16> as Neg>::Output

执行一元 - 运算。 Read more
1.14.0 · source§

impl Neg for &Wrapping<i32>

§

type Output = <Wrapping<i32> as Neg>::Output

应用 - 运算符后的结果类型。
source§

fn neg(self) -> <Wrapping<i32> as Neg>::Output

执行一元 - 运算。 Read more
1.14.0 · source§

impl Neg for &Wrapping<i64>

§

type Output = <Wrapping<i64> as Neg>::Output

应用 - 运算符后的结果类型。
source§

fn neg(self) -> <Wrapping<i64> as Neg>::Output

执行一元 - 运算。 Read more
1.14.0 · source§

impl Neg for &Wrapping<i8>

§

type Output = <Wrapping<i8> as Neg>::Output

应用 - 运算符后的结果类型。
source§

fn neg(self) -> <Wrapping<i8> as Neg>::Output

执行一元 - 运算。 Read more
1.14.0 · source§

impl Neg for &Wrapping<isize>

§

type Output = <Wrapping<isize> as Neg>::Output

应用 - 运算符后的结果类型。
source§

fn neg(self) -> <Wrapping<isize> as Neg>::Output

执行一元 - 运算。 Read more
1.14.0 · source§

impl Neg for &Wrapping<u128>

§

type Output = <Wrapping<u128> as Neg>::Output

应用 - 运算符后的结果类型。
source§

fn neg(self) -> <Wrapping<u128> as Neg>::Output

执行一元 - 运算。 Read more
1.14.0 · source§

impl Neg for &Wrapping<u16>

§

type Output = <Wrapping<u16> as Neg>::Output

应用 - 运算符后的结果类型。
source§

fn neg(self) -> <Wrapping<u16> as Neg>::Output

执行一元 - 运算。 Read more
1.14.0 · source§

impl Neg for &Wrapping<u32>

§

type Output = <Wrapping<u32> as Neg>::Output

应用 - 运算符后的结果类型。
source§

fn neg(self) -> <Wrapping<u32> as Neg>::Output

执行一元 - 运算。 Read more
1.14.0 · source§

impl Neg for &Wrapping<u64>

§

type Output = <Wrapping<u64> as Neg>::Output

应用 - 运算符后的结果类型。
source§

fn neg(self) -> <Wrapping<u64> as Neg>::Output

执行一元 - 运算。 Read more
1.14.0 · source§

impl Neg for &Wrapping<u8>

§

type Output = <Wrapping<u8> as Neg>::Output

应用 - 运算符后的结果类型。
source§

fn neg(self) -> <Wrapping<u8> as Neg>::Output

执行一元 - 运算。 Read more
1.14.0 · source§

impl Neg for &Wrapping<usize>

§

type Output = <Wrapping<usize> as Neg>::Output

应用 - 运算符后的结果类型。
source§

fn neg(self) -> <Wrapping<usize> as Neg>::Output

执行一元 - 运算。 Read more
1.10.0 · source§

impl Neg for Wrapping<i128>

§

type Output = Wrapping<i128>

应用 - 运算符后的结果类型。
source§

fn neg(self) -> Wrapping<i128>

执行一元 - 运算。 Read more
1.10.0 · source§

impl Neg for Wrapping<i16>

§

type Output = Wrapping<i16>

应用 - 运算符后的结果类型。
source§

fn neg(self) -> Wrapping<i16>

执行一元 - 运算。 Read more
1.10.0 · source§

impl Neg for Wrapping<i32>

§

type Output = Wrapping<i32>

应用 - 运算符后的结果类型。
source§

fn neg(self) -> Wrapping<i32>

执行一元 - 运算。 Read more
1.10.0 · source§

impl Neg for Wrapping<i64>

§

type Output = Wrapping<i64>

应用 - 运算符后的结果类型。
source§

fn neg(self) -> Wrapping<i64>

执行一元 - 运算。 Read more
1.10.0 · source§

impl Neg for Wrapping<i8>

§

type Output = Wrapping<i8>

应用 - 运算符后的结果类型。
source§

fn neg(self) -> Wrapping<i8>

执行一元 - 运算。 Read more
1.10.0 · source§

impl Neg for Wrapping<isize>

§

type Output = Wrapping<isize>

应用 - 运算符后的结果类型。
source§

fn neg(self) -> Wrapping<isize>

执行一元 - 运算。 Read more
1.10.0 · source§

impl Neg for Wrapping<u128>

§

type Output = Wrapping<u128>

应用 - 运算符后的结果类型。
source§

fn neg(self) -> Wrapping<u128>

执行一元 - 运算。 Read more
1.10.0 · source§

impl Neg for Wrapping<u16>

§

type Output = Wrapping<u16>

应用 - 运算符后的结果类型。
source§

fn neg(self) -> Wrapping<u16>

执行一元 - 运算。 Read more
1.10.0 · source§

impl Neg for Wrapping<u32>

§

type Output = Wrapping<u32>

应用 - 运算符后的结果类型。
source§

fn neg(self) -> Wrapping<u32>

执行一元 - 运算。 Read more
1.10.0 · source§

impl Neg for Wrapping<u64>

§

type Output = Wrapping<u64>

应用 - 运算符后的结果类型。
source§

fn neg(self) -> Wrapping<u64>

执行一元 - 运算。 Read more
1.10.0 · source§

impl Neg for Wrapping<u8>

§

type Output = Wrapping<u8>

应用 - 运算符后的结果类型。
source§

fn neg(self) -> Wrapping<u8>

执行一元 - 运算。 Read more
1.10.0 · source§

impl Neg for Wrapping<usize>

§

type Output = Wrapping<usize>

应用 - 运算符后的结果类型。
source§

fn neg(self) -> Wrapping<usize>

执行一元 - 运算。 Read more
1.14.0 · source§

impl Not for &Wrapping<i128>

§

type Output = <Wrapping<i128> as Not>::Output

应用 ! 运算符后的结果类型。
source§

fn not(self) -> <Wrapping<i128> as Not>::Output

执行一元 ! 操作。 Read more
1.14.0 · source§

impl Not for &Wrapping<i16>

§

type Output = <Wrapping<i16> as Not>::Output

应用 ! 运算符后的结果类型。
source§

fn not(self) -> <Wrapping<i16> as Not>::Output

执行一元 ! 操作。 Read more
1.14.0 · source§

impl Not for &Wrapping<i32>

§

type Output = <Wrapping<i32> as Not>::Output

应用 ! 运算符后的结果类型。
source§

fn not(self) -> <Wrapping<i32> as Not>::Output

执行一元 ! 操作。 Read more
1.14.0 · source§

impl Not for &Wrapping<i64>

§

type Output = <Wrapping<i64> as Not>::Output

应用 ! 运算符后的结果类型。
source§

fn not(self) -> <Wrapping<i64> as Not>::Output

执行一元 ! 操作。 Read more
1.14.0 · source§

impl Not for &Wrapping<i8>

§

type Output = <Wrapping<i8> as Not>::Output

应用 ! 运算符后的结果类型。
source§

fn not(self) -> <Wrapping<i8> as Not>::Output

执行一元 ! 操作。 Read more
1.14.0 · source§

impl Not for &Wrapping<isize>

§

type Output = <Wrapping<isize> as Not>::Output

应用 ! 运算符后的结果类型。
source§

fn not(self) -> <Wrapping<isize> as Not>::Output

执行一元 ! 操作。 Read more
1.14.0 · source§

impl Not for &Wrapping<u128>

§

type Output = <Wrapping<u128> as Not>::Output

应用 ! 运算符后的结果类型。
source§

fn not(self) -> <Wrapping<u128> as Not>::Output

执行一元 ! 操作。 Read more
1.14.0 · source§

impl Not for &Wrapping<u16>

§

type Output = <Wrapping<u16> as Not>::Output

应用 ! 运算符后的结果类型。
source§

fn not(self) -> <Wrapping<u16> as Not>::Output

执行一元 ! 操作。 Read more
1.14.0 · source§

impl Not for &Wrapping<u32>

§

type Output = <Wrapping<u32> as Not>::Output

应用 ! 运算符后的结果类型。
source§

fn not(self) -> <Wrapping<u32> as Not>::Output

执行一元 ! 操作。 Read more
1.14.0 · source§

impl Not for &Wrapping<u64>

§

type Output = <Wrapping<u64> as Not>::Output

应用 ! 运算符后的结果类型。
source§

fn not(self) -> <Wrapping<u64> as Not>::Output

执行一元 ! 操作。 Read more
1.14.0 · source§

impl Not for &Wrapping<u8>

§

type Output = <Wrapping<u8> as Not>::Output

应用 ! 运算符后的结果类型。
source§

fn not(self) -> <Wrapping<u8> as Not>::Output

执行一元 ! 操作。 Read more
1.14.0 · source§

impl Not for &Wrapping<usize>

§

type Output = <Wrapping<usize> as Not>::Output

应用 ! 运算符后的结果类型。
source§

fn not(self) -> <Wrapping<usize> as Not>::Output

执行一元 ! 操作。 Read more
source§

impl Not for Wrapping<i128>

§

type Output = Wrapping<i128>

应用 ! 运算符后的结果类型。
source§

fn not(self) -> Wrapping<i128>

执行一元 ! 操作。 Read more
source§

impl Not for Wrapping<i16>

§

type Output = Wrapping<i16>

应用 ! 运算符后的结果类型。
source§

fn not(self) -> Wrapping<i16>

执行一元 ! 操作。 Read more
source§

impl Not for Wrapping<i32>

§

type Output = Wrapping<i32>

应用 ! 运算符后的结果类型。
source§

fn not(self) -> Wrapping<i32>

执行一元 ! 操作。 Read more
source§

impl Not for Wrapping<i64>

§

type Output = Wrapping<i64>

应用 ! 运算符后的结果类型。
source§

fn not(self) -> Wrapping<i64>

执行一元 ! 操作。 Read more
source§

impl Not for Wrapping<i8>

§

type Output = Wrapping<i8>

应用 ! 运算符后的结果类型。
source§

fn not(self) -> Wrapping<i8>

执行一元 ! 操作。 Read more
source§

impl Not for Wrapping<isize>

§

type Output = Wrapping<isize>

应用 ! 运算符后的结果类型。
source§

fn not(self) -> Wrapping<isize>

执行一元 ! 操作。 Read more
source§

impl Not for Wrapping<u128>

§

type Output = Wrapping<u128>

应用 ! 运算符后的结果类型。
source§

fn not(self) -> Wrapping<u128>

执行一元 ! 操作。 Read more
source§

impl Not for Wrapping<u16>

§

type Output = Wrapping<u16>

应用 ! 运算符后的结果类型。
source§

fn not(self) -> Wrapping<u16>

执行一元 ! 操作。 Read more
source§

impl Not for Wrapping<u32>

§

type Output = Wrapping<u32>

应用 ! 运算符后的结果类型。
source§

fn not(self) -> Wrapping<u32>

执行一元 ! 操作。 Read more
source§

impl Not for Wrapping<u64>

§

type Output = Wrapping<u64>

应用 ! 运算符后的结果类型。
source§

fn not(self) -> Wrapping<u64>

执行一元 ! 操作。 Read more
source§

impl Not for Wrapping<u8>

§

type Output = Wrapping<u8>

应用 ! 运算符后的结果类型。
source§

fn not(self) -> Wrapping<u8>

执行一元 ! 操作。 Read more
source§

impl Not for Wrapping<usize>

§

type Output = Wrapping<usize>

应用 ! 运算符后的结果类型。
source§

fn not(self) -> Wrapping<usize>

执行一元 ! 操作。 Read more
1.11.0 · source§

impl<T> Octal for Wrapping<T>where T: Octal,

source§

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

使用给定的格式化程序格式化该值。
source§

impl<T> Ord for Wrapping<T>where T: Ord,

source§

fn cmp(&self, other: &Wrapping<T>) -> Ordering

此方法返回 selfother 之间的 OrderingRead more
1.21.0 · source§

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

比较并返回两个值中的最大值。 Read more
1.21.0 · source§

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

比较并返回两个值中的最小值。 Read more
1.50.0 · source§

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

将值限制在某个时间间隔内。 Read more
source§

impl<T> PartialEq<Wrapping<T>> for Wrapping<T>where T: PartialEq<T>,

source§

fn eq(&self, other: &Wrapping<T>) -> bool

此方法测试 selfother 值是否相等,并由 == 使用。
source§

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

此方法测试 !=。 默认实现几乎总是足够的,并且不应在没有充分理由的情况下被覆盖。
source§

impl<T> PartialOrd<Wrapping<T>> for Wrapping<T>where T: PartialOrd<T>,

source§

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

如果存在,则此方法返回 selfother 值之间的顺序。 Read more
source§

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

此方法测试的内容少于 (对于 selfother),并且由 < 操作员使用。 Read more
source§

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

此方法测试小于或等于 (对于 selfother),并且由 <= 运算符使用。 Read more
source§

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

此方法测试大于 (对于 selfother),并且由 > 操作员使用。 Read more
source§

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

此方法测试是否大于或等于 (对于 selfother),并且由 >= 运算符使用。 Read more
1.14.0 · source§

impl<'a> Product<&'a Wrapping<i128>> for Wrapping<i128>

source§

fn product<I>(iter: I) -> Wrapping<i128>where I: Iterator<Item = &'a Wrapping<i128>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl<'a> Product<&'a Wrapping<i16>> for Wrapping<i16>

source§

fn product<I>(iter: I) -> Wrapping<i16>where I: Iterator<Item = &'a Wrapping<i16>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl<'a> Product<&'a Wrapping<i32>> for Wrapping<i32>

source§

fn product<I>(iter: I) -> Wrapping<i32>where I: Iterator<Item = &'a Wrapping<i32>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl<'a> Product<&'a Wrapping<i64>> for Wrapping<i64>

source§

fn product<I>(iter: I) -> Wrapping<i64>where I: Iterator<Item = &'a Wrapping<i64>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl<'a> Product<&'a Wrapping<i8>> for Wrapping<i8>

source§

fn product<I>(iter: I) -> Wrapping<i8>where I: Iterator<Item = &'a Wrapping<i8>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl<'a> Product<&'a Wrapping<isize>> for Wrapping<isize>

source§

fn product<I>(iter: I) -> Wrapping<isize>where I: Iterator<Item = &'a Wrapping<isize>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl<'a> Product<&'a Wrapping<u128>> for Wrapping<u128>

source§

fn product<I>(iter: I) -> Wrapping<u128>where I: Iterator<Item = &'a Wrapping<u128>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl<'a> Product<&'a Wrapping<u16>> for Wrapping<u16>

source§

fn product<I>(iter: I) -> Wrapping<u16>where I: Iterator<Item = &'a Wrapping<u16>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl<'a> Product<&'a Wrapping<u32>> for Wrapping<u32>

source§

fn product<I>(iter: I) -> Wrapping<u32>where I: Iterator<Item = &'a Wrapping<u32>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl<'a> Product<&'a Wrapping<u64>> for Wrapping<u64>

source§

fn product<I>(iter: I) -> Wrapping<u64>where I: Iterator<Item = &'a Wrapping<u64>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl<'a> Product<&'a Wrapping<u8>> for Wrapping<u8>

source§

fn product<I>(iter: I) -> Wrapping<u8>where I: Iterator<Item = &'a Wrapping<u8>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl<'a> Product<&'a Wrapping<usize>> for Wrapping<usize>

source§

fn product<I>(iter: I) -> Wrapping<usize>where I: Iterator<Item = &'a Wrapping<usize>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl Product<Wrapping<i128>> for Wrapping<i128>

source§

fn product<I>(iter: I) -> Wrapping<i128>where I: Iterator<Item = Wrapping<i128>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl Product<Wrapping<i16>> for Wrapping<i16>

source§

fn product<I>(iter: I) -> Wrapping<i16>where I: Iterator<Item = Wrapping<i16>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl Product<Wrapping<i32>> for Wrapping<i32>

source§

fn product<I>(iter: I) -> Wrapping<i32>where I: Iterator<Item = Wrapping<i32>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl Product<Wrapping<i64>> for Wrapping<i64>

source§

fn product<I>(iter: I) -> Wrapping<i64>where I: Iterator<Item = Wrapping<i64>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl Product<Wrapping<i8>> for Wrapping<i8>

source§

fn product<I>(iter: I) -> Wrapping<i8>where I: Iterator<Item = Wrapping<i8>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl Product<Wrapping<isize>> for Wrapping<isize>

source§

fn product<I>(iter: I) -> Wrapping<isize>where I: Iterator<Item = Wrapping<isize>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl Product<Wrapping<u128>> for Wrapping<u128>

source§

fn product<I>(iter: I) -> Wrapping<u128>where I: Iterator<Item = Wrapping<u128>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl Product<Wrapping<u16>> for Wrapping<u16>

source§

fn product<I>(iter: I) -> Wrapping<u16>where I: Iterator<Item = Wrapping<u16>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl Product<Wrapping<u32>> for Wrapping<u32>

source§

fn product<I>(iter: I) -> Wrapping<u32>where I: Iterator<Item = Wrapping<u32>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl Product<Wrapping<u64>> for Wrapping<u64>

source§

fn product<I>(iter: I) -> Wrapping<u64>where I: Iterator<Item = Wrapping<u64>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl Product<Wrapping<u8>> for Wrapping<u8>

source§

fn product<I>(iter: I) -> Wrapping<u8>where I: Iterator<Item = Wrapping<u8>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl Product<Wrapping<usize>> for Wrapping<usize>

source§

fn product<I>(iter: I) -> Wrapping<usize>where I: Iterator<Item = Wrapping<usize>>,

该方法采用迭代器并通过乘以项从元素生成 Self
1.14.0 · source§

impl Rem<&Wrapping<i128>> for &Wrapping<i128>

§

type Output = <Wrapping<i128> as Rem<Wrapping<i128>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<i128> ) -> <Wrapping<i128> as Rem<Wrapping<i128>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<i128>> for Wrapping<i128>

§

type Output = <Wrapping<i128> as Rem<Wrapping<i128>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<i128> ) -> <Wrapping<i128> as Rem<Wrapping<i128>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<i16>> for &Wrapping<i16>

§

type Output = <Wrapping<i16> as Rem<Wrapping<i16>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<i16> ) -> <Wrapping<i16> as Rem<Wrapping<i16>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<i16>> for Wrapping<i16>

§

type Output = <Wrapping<i16> as Rem<Wrapping<i16>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<i16> ) -> <Wrapping<i16> as Rem<Wrapping<i16>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<i32>> for &Wrapping<i32>

§

type Output = <Wrapping<i32> as Rem<Wrapping<i32>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<i32> ) -> <Wrapping<i32> as Rem<Wrapping<i32>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<i32>> for Wrapping<i32>

§

type Output = <Wrapping<i32> as Rem<Wrapping<i32>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<i32> ) -> <Wrapping<i32> as Rem<Wrapping<i32>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<i64>> for &Wrapping<i64>

§

type Output = <Wrapping<i64> as Rem<Wrapping<i64>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<i64> ) -> <Wrapping<i64> as Rem<Wrapping<i64>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<i64>> for Wrapping<i64>

§

type Output = <Wrapping<i64> as Rem<Wrapping<i64>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<i64> ) -> <Wrapping<i64> as Rem<Wrapping<i64>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<i8>> for &Wrapping<i8>

§

type Output = <Wrapping<i8> as Rem<Wrapping<i8>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<i8> ) -> <Wrapping<i8> as Rem<Wrapping<i8>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<i8>> for Wrapping<i8>

§

type Output = <Wrapping<i8> as Rem<Wrapping<i8>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<i8> ) -> <Wrapping<i8> as Rem<Wrapping<i8>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<isize>> for &Wrapping<isize>

§

type Output = <Wrapping<isize> as Rem<Wrapping<isize>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<isize> ) -> <Wrapping<isize> as Rem<Wrapping<isize>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<isize>> for Wrapping<isize>

§

type Output = <Wrapping<isize> as Rem<Wrapping<isize>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<isize> ) -> <Wrapping<isize> as Rem<Wrapping<isize>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<u128>> for &Wrapping<u128>

§

type Output = <Wrapping<u128> as Rem<Wrapping<u128>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<u128> ) -> <Wrapping<u128> as Rem<Wrapping<u128>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<u128>> for Wrapping<u128>

§

type Output = <Wrapping<u128> as Rem<Wrapping<u128>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<u128> ) -> <Wrapping<u128> as Rem<Wrapping<u128>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<u16>> for &Wrapping<u16>

§

type Output = <Wrapping<u16> as Rem<Wrapping<u16>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<u16> ) -> <Wrapping<u16> as Rem<Wrapping<u16>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<u16>> for Wrapping<u16>

§

type Output = <Wrapping<u16> as Rem<Wrapping<u16>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<u16> ) -> <Wrapping<u16> as Rem<Wrapping<u16>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<u32>> for &Wrapping<u32>

§

type Output = <Wrapping<u32> as Rem<Wrapping<u32>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<u32> ) -> <Wrapping<u32> as Rem<Wrapping<u32>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<u32>> for Wrapping<u32>

§

type Output = <Wrapping<u32> as Rem<Wrapping<u32>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<u32> ) -> <Wrapping<u32> as Rem<Wrapping<u32>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<u64>> for &Wrapping<u64>

§

type Output = <Wrapping<u64> as Rem<Wrapping<u64>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<u64> ) -> <Wrapping<u64> as Rem<Wrapping<u64>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<u64>> for Wrapping<u64>

§

type Output = <Wrapping<u64> as Rem<Wrapping<u64>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<u64> ) -> <Wrapping<u64> as Rem<Wrapping<u64>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<u8>> for &Wrapping<u8>

§

type Output = <Wrapping<u8> as Rem<Wrapping<u8>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<u8> ) -> <Wrapping<u8> as Rem<Wrapping<u8>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<u8>> for Wrapping<u8>

§

type Output = <Wrapping<u8> as Rem<Wrapping<u8>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<u8> ) -> <Wrapping<u8> as Rem<Wrapping<u8>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<usize>> for &Wrapping<usize>

§

type Output = <Wrapping<usize> as Rem<Wrapping<usize>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<usize> ) -> <Wrapping<usize> as Rem<Wrapping<usize>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl Rem<&Wrapping<usize>> for Wrapping<usize>

§

type Output = <Wrapping<usize> as Rem<Wrapping<usize>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: &Wrapping<usize> ) -> <Wrapping<usize> as Rem<Wrapping<usize>>>::Output

执行 % 操作。 Read more
1.14.0 · source§

impl<'a> Rem<Wrapping<i128>> for &'a Wrapping<i128>

§

type Output = <Wrapping<i128> as Rem<Wrapping<i128>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: Wrapping<i128> ) -> <Wrapping<i128> as Rem<Wrapping<i128>>>::Output

执行 % 操作。 Read more
1.7.0 · source§

impl Rem<Wrapping<i128>> for Wrapping<i128>

§

type Output = Wrapping<i128>

应用 % 运算符后的结果类型。
source§

fn rem(self, other: Wrapping<i128>) -> Wrapping<i128>

执行 % 操作。 Read more
1.14.0 · source§

impl<'a> Rem<Wrapping<i16>> for &'a Wrapping<i16>

§

type Output = <Wrapping<i16> as Rem<Wrapping<i16>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: Wrapping<i16> ) -> <Wrapping<i16> as Rem<Wrapping<i16>>>::Output

执行 % 操作。 Read more
1.7.0 · source§

impl Rem<Wrapping<i16>> for Wrapping<i16>

§

type Output = Wrapping<i16>

应用 % 运算符后的结果类型。
source§

fn rem(self, other: Wrapping<i16>) -> Wrapping<i16>

执行 % 操作。 Read more
1.14.0 · source§

impl<'a> Rem<Wrapping<i32>> for &'a Wrapping<i32>

§

type Output = <Wrapping<i32> as Rem<Wrapping<i32>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: Wrapping<i32> ) -> <Wrapping<i32> as Rem<Wrapping<i32>>>::Output

执行 % 操作。 Read more
1.7.0 · source§

impl Rem<Wrapping<i32>> for Wrapping<i32>

§

type Output = Wrapping<i32>

应用 % 运算符后的结果类型。
source§

fn rem(self, other: Wrapping<i32>) -> Wrapping<i32>

执行 % 操作。 Read more
1.14.0 · source§

impl<'a> Rem<Wrapping<i64>> for &'a Wrapping<i64>

§

type Output = <Wrapping<i64> as Rem<Wrapping<i64>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: Wrapping<i64> ) -> <Wrapping<i64> as Rem<Wrapping<i64>>>::Output

执行 % 操作。 Read more
1.7.0 · source§

impl Rem<Wrapping<i64>> for Wrapping<i64>

§

type Output = Wrapping<i64>

应用 % 运算符后的结果类型。
source§

fn rem(self, other: Wrapping<i64>) -> Wrapping<i64>

执行 % 操作。 Read more
1.14.0 · source§

impl<'a> Rem<Wrapping<i8>> for &'a Wrapping<i8>

§

type Output = <Wrapping<i8> as Rem<Wrapping<i8>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem(self, other: Wrapping<i8>) -> <Wrapping<i8> as Rem<Wrapping<i8>>>::Output

执行 % 操作。 Read more
1.7.0 · source§

impl Rem<Wrapping<i8>> for Wrapping<i8>

§

type Output = Wrapping<i8>

应用 % 运算符后的结果类型。
source§

fn rem(self, other: Wrapping<i8>) -> Wrapping<i8>

执行 % 操作。 Read more
1.14.0 · source§

impl<'a> Rem<Wrapping<isize>> for &'a Wrapping<isize>

§

type Output = <Wrapping<isize> as Rem<Wrapping<isize>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: Wrapping<isize> ) -> <Wrapping<isize> as Rem<Wrapping<isize>>>::Output

执行 % 操作。 Read more
1.7.0 · source§

impl Rem<Wrapping<isize>> for Wrapping<isize>

§

type Output = Wrapping<isize>

应用 % 运算符后的结果类型。
source§

fn rem(self, other: Wrapping<isize>) -> Wrapping<isize>

执行 % 操作。 Read more
1.14.0 · source§

impl<'a> Rem<Wrapping<u128>> for &'a Wrapping<u128>

§

type Output = <Wrapping<u128> as Rem<Wrapping<u128>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: Wrapping<u128> ) -> <Wrapping<u128> as Rem<Wrapping<u128>>>::Output

执行 % 操作。 Read more
1.7.0 · source§

impl Rem<Wrapping<u128>> for Wrapping<u128>

§

type Output = Wrapping<u128>

应用 % 运算符后的结果类型。
source§

fn rem(self, other: Wrapping<u128>) -> Wrapping<u128>

执行 % 操作。 Read more
1.14.0 · source§

impl<'a> Rem<Wrapping<u16>> for &'a Wrapping<u16>

§

type Output = <Wrapping<u16> as Rem<Wrapping<u16>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: Wrapping<u16> ) -> <Wrapping<u16> as Rem<Wrapping<u16>>>::Output

执行 % 操作。 Read more
1.7.0 · source§

impl Rem<Wrapping<u16>> for Wrapping<u16>

§

type Output = Wrapping<u16>

应用 % 运算符后的结果类型。
source§

fn rem(self, other: Wrapping<u16>) -> Wrapping<u16>

执行 % 操作。 Read more
1.14.0 · source§

impl<'a> Rem<Wrapping<u32>> for &'a Wrapping<u32>

§

type Output = <Wrapping<u32> as Rem<Wrapping<u32>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: Wrapping<u32> ) -> <Wrapping<u32> as Rem<Wrapping<u32>>>::Output

执行 % 操作。 Read more
1.7.0 · source§

impl Rem<Wrapping<u32>> for Wrapping<u32>

§

type Output = Wrapping<u32>

应用 % 运算符后的结果类型。
source§

fn rem(self, other: Wrapping<u32>) -> Wrapping<u32>

执行 % 操作。 Read more
1.14.0 · source§

impl<'a> Rem<Wrapping<u64>> for &'a Wrapping<u64>

§

type Output = <Wrapping<u64> as Rem<Wrapping<u64>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: Wrapping<u64> ) -> <Wrapping<u64> as Rem<Wrapping<u64>>>::Output

执行 % 操作。 Read more
1.7.0 · source§

impl Rem<Wrapping<u64>> for Wrapping<u64>

§

type Output = Wrapping<u64>

应用 % 运算符后的结果类型。
source§

fn rem(self, other: Wrapping<u64>) -> Wrapping<u64>

执行 % 操作。 Read more
1.14.0 · source§

impl<'a> Rem<Wrapping<u8>> for &'a Wrapping<u8>

§

type Output = <Wrapping<u8> as Rem<Wrapping<u8>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem(self, other: Wrapping<u8>) -> <Wrapping<u8> as Rem<Wrapping<u8>>>::Output

执行 % 操作。 Read more
1.7.0 · source§

impl Rem<Wrapping<u8>> for Wrapping<u8>

§

type Output = Wrapping<u8>

应用 % 运算符后的结果类型。
source§

fn rem(self, other: Wrapping<u8>) -> Wrapping<u8>

执行 % 操作。 Read more
1.14.0 · source§

impl<'a> Rem<Wrapping<usize>> for &'a Wrapping<usize>

§

type Output = <Wrapping<usize> as Rem<Wrapping<usize>>>::Output

应用 % 运算符后的结果类型。
source§

fn rem( self, other: Wrapping<usize> ) -> <Wrapping<usize> as Rem<Wrapping<usize>>>::Output

执行 % 操作。 Read more
1.7.0 · source§

impl Rem<Wrapping<usize>> for Wrapping<usize>

§

type Output = Wrapping<usize>

应用 % 运算符后的结果类型。
source§

fn rem(self, other: Wrapping<usize>) -> Wrapping<usize>

执行 % 操作。 Read more
1.22.0 · source§

impl RemAssign<&Wrapping<i128>> for Wrapping<i128>

source§

fn rem_assign(&mut self, other: &Wrapping<i128>)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&Wrapping<i16>> for Wrapping<i16>

source§

fn rem_assign(&mut self, other: &Wrapping<i16>)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&Wrapping<i32>> for Wrapping<i32>

source§

fn rem_assign(&mut self, other: &Wrapping<i32>)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&Wrapping<i64>> for Wrapping<i64>

source§

fn rem_assign(&mut self, other: &Wrapping<i64>)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&Wrapping<i8>> for Wrapping<i8>

source§

fn rem_assign(&mut self, other: &Wrapping<i8>)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&Wrapping<isize>> for Wrapping<isize>

source§

fn rem_assign(&mut self, other: &Wrapping<isize>)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&Wrapping<u128>> for Wrapping<u128>

source§

fn rem_assign(&mut self, other: &Wrapping<u128>)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&Wrapping<u16>> for Wrapping<u16>

source§

fn rem_assign(&mut self, other: &Wrapping<u16>)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&Wrapping<u32>> for Wrapping<u32>

source§

fn rem_assign(&mut self, other: &Wrapping<u32>)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&Wrapping<u64>> for Wrapping<u64>

source§

fn rem_assign(&mut self, other: &Wrapping<u64>)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&Wrapping<u8>> for Wrapping<u8>

source§

fn rem_assign(&mut self, other: &Wrapping<u8>)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&Wrapping<usize>> for Wrapping<usize>

source§

fn rem_assign(&mut self, other: &Wrapping<usize>)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&i128> for Wrapping<i128>

source§

fn rem_assign(&mut self, other: &i128)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&i16> for Wrapping<i16>

source§

fn rem_assign(&mut self, other: &i16)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&i32> for Wrapping<i32>

source§

fn rem_assign(&mut self, other: &i32)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&i64> for Wrapping<i64>

source§

fn rem_assign(&mut self, other: &i64)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&i8> for Wrapping<i8>

source§

fn rem_assign(&mut self, other: &i8)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&isize> for Wrapping<isize>

source§

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

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&u128> for Wrapping<u128>

source§

fn rem_assign(&mut self, other: &u128)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&u16> for Wrapping<u16>

source§

fn rem_assign(&mut self, other: &u16)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&u32> for Wrapping<u32>

source§

fn rem_assign(&mut self, other: &u32)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&u64> for Wrapping<u64>

source§

fn rem_assign(&mut self, other: &u64)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&u8> for Wrapping<u8>

source§

fn rem_assign(&mut self, other: &u8)

执行 %= 操作。 Read more
1.22.0 · source§

impl RemAssign<&usize> for Wrapping<usize>

source§

fn rem_assign(&mut self, other: &usize)

执行 %= 操作。 Read more
1.8.0 · source§

impl RemAssign<Wrapping<i128>> for Wrapping<i128>

source§

fn rem_assign(&mut self, other: Wrapping<i128>)

执行 %= 操作。 Read more
1.8.0 · source§

impl RemAssign<Wrapping<i16>> for Wrapping<i16>

source§

fn rem_assign(&mut self, other: Wrapping<i16>)

执行 %= 操作。 Read more
1.8.0 · source§

impl RemAssign<Wrapping<i32>> for Wrapping<i32>

source§

fn rem_assign(&mut self, other: Wrapping<i32>)

执行 %= 操作。 Read more
1.8.0 · source§

impl RemAssign<Wrapping<i64>> for Wrapping<i64>

source§

fn rem_assign(&mut self, other: Wrapping<i64>)

执行 %= 操作。 Read more
1.8.0 · source§

impl RemAssign<Wrapping<i8>> for Wrapping<i8>

source§

fn rem_assign(&mut self, other: Wrapping<i8>)

执行 %= 操作。 Read more
1.8.0 · source§

impl RemAssign<Wrapping<isize>> for Wrapping<isize>

source§

fn rem_assign(&mut self, other: Wrapping<isize>)

执行 %= 操作。 Read more
1.8.0 · source§

impl RemAssign<Wrapping<u128>> for Wrapping<u128>

source§

fn rem_assign(&mut self, other: Wrapping<u128>)

执行 %= 操作。 Read more
1.8.0 · source§

impl RemAssign<Wrapping<u16>> for Wrapping<u16>

source§

fn rem_assign(&mut self, other: Wrapping<u16>)

执行 %= 操作。 Read more
1.8.0 · source§

impl RemAssign<Wrapping<u32>> for Wrapping<u32>

source§

fn rem_assign(&mut self, other: Wrapping<u32>)

执行 %= 操作。 Read more
1.8.0 · source§

impl RemAssign<Wrapping<u64>> for Wrapping<u64>

source§

fn rem_assign(&mut self, other: Wrapping<u64>)

执行 %= 操作。 Read more
1.8.0 · source§

impl RemAssign<Wrapping<u8>> for Wrapping<u8>

source§

fn rem_assign(&mut self, other: Wrapping<u8>)

执行 %= 操作。 Read more
1.8.0 · source§

impl RemAssign<Wrapping<usize>> for Wrapping<usize>

source§

fn rem_assign(&mut self, other: Wrapping<usize>)

执行 %= 操作。 Read more
1.60.0 · source§

impl RemAssign<i128> for Wrapping<i128>

source§

fn rem_assign(&mut self, other: i128)

执行 %= 操作。 Read more
1.60.0 · source§

impl RemAssign<i16> for Wrapping<i16>

source§

fn rem_assign(&mut self, other: i16)

执行 %= 操作。 Read more
1.60.0 · source§

impl RemAssign<i32> for Wrapping<i32>

source§

fn rem_assign(&mut self, other: i32)

执行 %= 操作。 Read more
1.60.0 · source§

impl RemAssign<i64> for Wrapping<i64>

source§

fn rem_assign(&mut self, other: i64)

执行 %= 操作。 Read more
1.60.0 · source§

impl RemAssign<i8> for Wrapping<i8>

source§

fn rem_assign(&mut self, other: i8)

执行 %= 操作。 Read more
1.60.0 · source§

impl RemAssign<isize> for Wrapping<isize>

source§

fn rem_assign(&mut self, other: isize)

执行 %= 操作。 Read more
1.60.0 · source§

impl RemAssign<u128> for Wrapping<u128>

source§

fn rem_assign(&mut self, other: u128)

执行 %= 操作。 Read more
1.60.0 · source§

impl RemAssign<u16> for Wrapping<u16>

source§

fn rem_assign(&mut self, other: u16)

执行 %= 操作。 Read more
1.60.0 · source§

impl RemAssign<u32> for Wrapping<u32>

source§

fn rem_assign(&mut self, other: u32)

执行 %= 操作。 Read more
1.60.0 · source§

impl RemAssign<u64> for Wrapping<u64>

source§

fn rem_assign(&mut self, other: u64)

执行 %= 操作。 Read more
1.60.0 · source§

impl RemAssign<u8> for Wrapping<u8>

source§

fn rem_assign(&mut self, other: u8)

执行 %= 操作。 Read more
1.60.0 · source§

impl RemAssign<usize> for Wrapping<usize>

source§

fn rem_assign(&mut self, other: usize)

执行 %= 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for &Wrapping<i128>

§

type Output = <Wrapping<i128> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<i128> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for &Wrapping<i16>

§

type Output = <Wrapping<i16> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<i16> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for &Wrapping<i32>

§

type Output = <Wrapping<i32> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<i32> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for &Wrapping<i64>

§

type Output = <Wrapping<i64> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<i64> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for &Wrapping<i8>

§

type Output = <Wrapping<i8> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<i8> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for &Wrapping<isize>

§

type Output = <Wrapping<isize> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<isize> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for &Wrapping<u128>

§

type Output = <Wrapping<u128> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<u128> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for &Wrapping<u16>

§

type Output = <Wrapping<u16> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<u16> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for &Wrapping<u32>

§

type Output = <Wrapping<u32> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<u32> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for &Wrapping<u64>

§

type Output = <Wrapping<u64> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<u64> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for &Wrapping<u8>

§

type Output = <Wrapping<u8> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<u8> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for &Wrapping<usize>

§

type Output = <Wrapping<usize> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<usize> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for Wrapping<i128>

§

type Output = <Wrapping<i128> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<i128> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for Wrapping<i16>

§

type Output = <Wrapping<i16> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<i16> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for Wrapping<i32>

§

type Output = <Wrapping<i32> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<i32> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for Wrapping<i64>

§

type Output = <Wrapping<i64> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<i64> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for Wrapping<i8>

§

type Output = <Wrapping<i8> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<i8> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for Wrapping<isize>

§

type Output = <Wrapping<isize> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<isize> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for Wrapping<u128>

§

type Output = <Wrapping<u128> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<u128> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for Wrapping<u16>

§

type Output = <Wrapping<u16> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<u16> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for Wrapping<u32>

§

type Output = <Wrapping<u32> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<u32> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for Wrapping<u64>

§

type Output = <Wrapping<u64> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<u64> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for Wrapping<u8>

§

type Output = <Wrapping<u8> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<u8> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl Shl<&usize> for Wrapping<usize>

§

type Output = <Wrapping<usize> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: &usize) -> <Wrapping<usize> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl<'a> Shl<usize> for &'a Wrapping<i128>

§

type Output = <Wrapping<i128> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> <Wrapping<i128> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl<'a> Shl<usize> for &'a Wrapping<i16>

§

type Output = <Wrapping<i16> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> <Wrapping<i16> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl<'a> Shl<usize> for &'a Wrapping<i32>

§

type Output = <Wrapping<i32> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> <Wrapping<i32> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl<'a> Shl<usize> for &'a Wrapping<i64>

§

type Output = <Wrapping<i64> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> <Wrapping<i64> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl<'a> Shl<usize> for &'a Wrapping<i8>

§

type Output = <Wrapping<i8> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> <Wrapping<i8> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl<'a> Shl<usize> for &'a Wrapping<isize>

§

type Output = <Wrapping<isize> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> <Wrapping<isize> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl<'a> Shl<usize> for &'a Wrapping<u128>

§

type Output = <Wrapping<u128> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> <Wrapping<u128> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl<'a> Shl<usize> for &'a Wrapping<u16>

§

type Output = <Wrapping<u16> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> <Wrapping<u16> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl<'a> Shl<usize> for &'a Wrapping<u32>

§

type Output = <Wrapping<u32> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> <Wrapping<u32> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl<'a> Shl<usize> for &'a Wrapping<u64>

§

type Output = <Wrapping<u64> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> <Wrapping<u64> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl<'a> Shl<usize> for &'a Wrapping<u8>

§

type Output = <Wrapping<u8> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> <Wrapping<u8> as Shl<usize>>::Output

执行 << 操作。 Read more
1.39.0 · source§

impl<'a> Shl<usize> for &'a Wrapping<usize>

§

type Output = <Wrapping<usize> as Shl<usize>>::Output

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> <Wrapping<usize> as Shl<usize>>::Output

执行 << 操作。 Read more
source§

impl Shl<usize> for Wrapping<i128>

§

type Output = Wrapping<i128>

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> Wrapping<i128>

执行 << 操作。 Read more
source§

impl Shl<usize> for Wrapping<i16>

§

type Output = Wrapping<i16>

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> Wrapping<i16>

执行 << 操作。 Read more
source§

impl Shl<usize> for Wrapping<i32>

§

type Output = Wrapping<i32>

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> Wrapping<i32>

执行 << 操作。 Read more
source§

impl Shl<usize> for Wrapping<i64>

§

type Output = Wrapping<i64>

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> Wrapping<i64>

执行 << 操作。 Read more
source§

impl Shl<usize> for Wrapping<i8>

§

type Output = Wrapping<i8>

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> Wrapping<i8>

执行 << 操作。 Read more
source§

impl Shl<usize> for Wrapping<isize>

§

type Output = Wrapping<isize>

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> Wrapping<isize>

执行 << 操作。 Read more
source§

impl Shl<usize> for Wrapping<u128>

§

type Output = Wrapping<u128>

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> Wrapping<u128>

执行 << 操作。 Read more
source§

impl Shl<usize> for Wrapping<u16>

§

type Output = Wrapping<u16>

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> Wrapping<u16>

执行 << 操作。 Read more
source§

impl Shl<usize> for Wrapping<u32>

§

type Output = Wrapping<u32>

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> Wrapping<u32>

执行 << 操作。 Read more
source§

impl Shl<usize> for Wrapping<u64>

§

type Output = Wrapping<u64>

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> Wrapping<u64>

执行 << 操作。 Read more
source§

impl Shl<usize> for Wrapping<u8>

§

type Output = Wrapping<u8>

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> Wrapping<u8>

执行 << 操作。 Read more
source§

impl Shl<usize> for Wrapping<usize>

§

type Output = Wrapping<usize>

应用 << 运算符后的结果类型。
source§

fn shl(self, other: usize) -> Wrapping<usize>

执行 << 操作。 Read more
1.22.0 · source§

impl ShlAssign<&usize> for Wrapping<i128>

source§

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。 Read more
1.22.0 · source§

impl ShlAssign<&usize> for Wrapping<i16>

source§

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。 Read more
1.22.0 · source§

impl ShlAssign<&usize> for Wrapping<i32>

source§

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。 Read more
1.22.0 · source§

impl ShlAssign<&usize> for Wrapping<i64>

source§

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。 Read more
1.22.0 · source§

impl ShlAssign<&usize> for Wrapping<i8>

source§

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。 Read more
1.22.0 · source§

impl ShlAssign<&usize> for Wrapping<isize>

source§

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。 Read more
1.22.0 · source§

impl ShlAssign<&usize> for Wrapping<u128>

source§

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。 Read more
1.22.0 · source§

impl ShlAssign<&usize> for Wrapping<u16>

source§

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。 Read more
1.22.0 · source§

impl ShlAssign<&usize> for Wrapping<u32>

source§

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。 Read more
1.22.0 · source§

impl ShlAssign<&usize> for Wrapping<u64>

source§

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。 Read more
1.22.0 · source§

impl ShlAssign<&usize> for Wrapping<u8>

source§

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。 Read more
1.22.0 · source§

impl ShlAssign<&usize> for Wrapping<usize>

source§

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。 Read more
1.8.0 · source§

impl ShlAssign<usize> for Wrapping<i128>

source§

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。 Read more
1.8.0 · source§

impl ShlAssign<usize> for Wrapping<i16>

source§

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。 Read more
1.8.0 · source§

impl ShlAssign<usize> for Wrapping<i32>

source§

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。 Read more
1.8.0 · source§

impl ShlAssign<usize> for Wrapping<i64>

source§

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。 Read more
1.8.0 · source§

impl ShlAssign<usize> for Wrapping<i8>

source§

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。 Read more
1.8.0 · source§

impl ShlAssign<usize> for Wrapping<isize>

source§

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。 Read more
1.8.0 · source§

impl ShlAssign<usize> for Wrapping<u128>

source§

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。 Read more
1.8.0 · source§

impl ShlAssign<usize> for Wrapping<u16>

source§

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。 Read more
1.8.0 · source§

impl ShlAssign<usize> for Wrapping<u32>

source§

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。 Read more
1.8.0 · source§

impl ShlAssign<usize> for Wrapping<u64>

source§

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。 Read more
1.8.0 · source§

impl ShlAssign<usize> for Wrapping<u8>

source§

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。 Read more
1.8.0 · source§

impl ShlAssign<usize> for Wrapping<usize>

source§

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for &Wrapping<i128>

§

type Output = <Wrapping<i128> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<i128> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for &Wrapping<i16>

§

type Output = <Wrapping<i16> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<i16> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for &Wrapping<i32>

§

type Output = <Wrapping<i32> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<i32> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for &Wrapping<i64>

§

type Output = <Wrapping<i64> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<i64> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for &Wrapping<i8>

§

type Output = <Wrapping<i8> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<i8> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for &Wrapping<isize>

§

type Output = <Wrapping<isize> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<isize> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for &Wrapping<u128>

§

type Output = <Wrapping<u128> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<u128> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for &Wrapping<u16>

§

type Output = <Wrapping<u16> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<u16> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for &Wrapping<u32>

§

type Output = <Wrapping<u32> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<u32> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for &Wrapping<u64>

§

type Output = <Wrapping<u64> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<u64> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for &Wrapping<u8>

§

type Output = <Wrapping<u8> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<u8> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for &Wrapping<usize>

§

type Output = <Wrapping<usize> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<usize> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for Wrapping<i128>

§

type Output = <Wrapping<i128> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<i128> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for Wrapping<i16>

§

type Output = <Wrapping<i16> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<i16> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for Wrapping<i32>

§

type Output = <Wrapping<i32> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<i32> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for Wrapping<i64>

§

type Output = <Wrapping<i64> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<i64> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for Wrapping<i8>

§

type Output = <Wrapping<i8> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<i8> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for Wrapping<isize>

§

type Output = <Wrapping<isize> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<isize> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for Wrapping<u128>

§

type Output = <Wrapping<u128> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<u128> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for Wrapping<u16>

§

type Output = <Wrapping<u16> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<u16> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for Wrapping<u32>

§

type Output = <Wrapping<u32> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<u32> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for Wrapping<u64>

§

type Output = <Wrapping<u64> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<u64> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for Wrapping<u8>

§

type Output = <Wrapping<u8> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<u8> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl Shr<&usize> for Wrapping<usize>

§

type Output = <Wrapping<usize> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: &usize) -> <Wrapping<usize> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl<'a> Shr<usize> for &'a Wrapping<i128>

§

type Output = <Wrapping<i128> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> <Wrapping<i128> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl<'a> Shr<usize> for &'a Wrapping<i16>

§

type Output = <Wrapping<i16> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> <Wrapping<i16> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl<'a> Shr<usize> for &'a Wrapping<i32>

§

type Output = <Wrapping<i32> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> <Wrapping<i32> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl<'a> Shr<usize> for &'a Wrapping<i64>

§

type Output = <Wrapping<i64> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> <Wrapping<i64> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl<'a> Shr<usize> for &'a Wrapping<i8>

§

type Output = <Wrapping<i8> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> <Wrapping<i8> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl<'a> Shr<usize> for &'a Wrapping<isize>

§

type Output = <Wrapping<isize> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> <Wrapping<isize> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl<'a> Shr<usize> for &'a Wrapping<u128>

§

type Output = <Wrapping<u128> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> <Wrapping<u128> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl<'a> Shr<usize> for &'a Wrapping<u16>

§

type Output = <Wrapping<u16> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> <Wrapping<u16> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl<'a> Shr<usize> for &'a Wrapping<u32>

§

type Output = <Wrapping<u32> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> <Wrapping<u32> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl<'a> Shr<usize> for &'a Wrapping<u64>

§

type Output = <Wrapping<u64> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> <Wrapping<u64> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl<'a> Shr<usize> for &'a Wrapping<u8>

§

type Output = <Wrapping<u8> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> <Wrapping<u8> as Shr<usize>>::Output

执行 >> 操作。 Read more
1.39.0 · source§

impl<'a> Shr<usize> for &'a Wrapping<usize>

§

type Output = <Wrapping<usize> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> <Wrapping<usize> as Shr<usize>>::Output

执行 >> 操作。 Read more
source§

impl Shr<usize> for Wrapping<i128>

§

type Output = Wrapping<i128>

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> Wrapping<i128>

执行 >> 操作。 Read more
source§

impl Shr<usize> for Wrapping<i16>

§

type Output = Wrapping<i16>

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> Wrapping<i16>

执行 >> 操作。 Read more
source§

impl Shr<usize> for Wrapping<i32>

§

type Output = Wrapping<i32>

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> Wrapping<i32>

执行 >> 操作。 Read more
source§

impl Shr<usize> for Wrapping<i64>

§

type Output = Wrapping<i64>

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> Wrapping<i64>

执行 >> 操作。 Read more
source§

impl Shr<usize> for Wrapping<i8>

§

type Output = Wrapping<i8>

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> Wrapping<i8>

执行 >> 操作。 Read more
source§

impl Shr<usize> for Wrapping<isize>

§

type Output = Wrapping<isize>

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> Wrapping<isize>

执行 >> 操作。 Read more
source§

impl Shr<usize> for Wrapping<u128>

§

type Output = Wrapping<u128>

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> Wrapping<u128>

执行 >> 操作。 Read more
source§

impl Shr<usize> for Wrapping<u16>

§

type Output = Wrapping<u16>

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> Wrapping<u16>

执行 >> 操作。 Read more
source§

impl Shr<usize> for Wrapping<u32>

§

type Output = Wrapping<u32>

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> Wrapping<u32>

执行 >> 操作。 Read more
source§

impl Shr<usize> for Wrapping<u64>

§

type Output = Wrapping<u64>

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> Wrapping<u64>

执行 >> 操作。 Read more
source§

impl Shr<usize> for Wrapping<u8>

§

type Output = Wrapping<u8>

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> Wrapping<u8>

执行 >> 操作。 Read more
source§

impl Shr<usize> for Wrapping<usize>

§

type Output = Wrapping<usize>

应用 >> 运算符后的结果类型。
source§

fn shr(self, other: usize) -> Wrapping<usize>

执行 >> 操作。 Read more
1.22.0 · source§

impl ShrAssign<&usize> for Wrapping<i128>

source§

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。 Read more
1.22.0 · source§

impl ShrAssign<&usize> for Wrapping<i16>

source§

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。 Read more
1.22.0 · source§

impl ShrAssign<&usize> for Wrapping<i32>

source§

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。 Read more
1.22.0 · source§

impl ShrAssign<&usize> for Wrapping<i64>

source§

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。 Read more
1.22.0 · source§

impl ShrAssign<&usize> for Wrapping<i8>

source§

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。 Read more
1.22.0 · source§

impl ShrAssign<&usize> for Wrapping<isize>

source§

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。 Read more
1.22.0 · source§

impl ShrAssign<&usize> for Wrapping<u128>

source§

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。 Read more
1.22.0 · source§

impl ShrAssign<&usize> for Wrapping<u16>

source§

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。 Read more
1.22.0 · source§

impl ShrAssign<&usize> for Wrapping<u32>

source§

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。 Read more
1.22.0 · source§

impl ShrAssign<&usize> for Wrapping<u64>

source§

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。 Read more
1.22.0 · source§

impl ShrAssign<&usize> for Wrapping<u8>

source§

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。 Read more
1.22.0 · source§

impl ShrAssign<&usize> for Wrapping<usize>

source§

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。 Read more
1.8.0 · source§

impl ShrAssign<usize> for Wrapping<i128>

source§

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。 Read more
1.8.0 · source§

impl ShrAssign<usize> for Wrapping<i16>

source§

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。 Read more
1.8.0 · source§

impl ShrAssign<usize> for Wrapping<i32>

source§

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。 Read more
1.8.0 · source§

impl ShrAssign<usize> for Wrapping<i64>

source§

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。 Read more
1.8.0 · source§

impl ShrAssign<usize> for Wrapping<i8>

source§

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。 Read more
1.8.0 · source§

impl ShrAssign<usize> for Wrapping<isize>

source§

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。 Read more
1.8.0 · source§

impl ShrAssign<usize> for Wrapping<u128>

source§

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。 Read more
1.8.0 · source§

impl ShrAssign<usize> for Wrapping<u16>

source§

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。 Read more
1.8.0 · source§

impl ShrAssign<usize> for Wrapping<u32>

source§

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。 Read more
1.8.0 · source§

impl ShrAssign<usize> for Wrapping<u64>

source§

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。 Read more
1.8.0 · source§

impl ShrAssign<usize> for Wrapping<u8>

source§

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。 Read more
1.8.0 · source§

impl ShrAssign<usize> for Wrapping<usize>

source§

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<i128>> for &Wrapping<i128>

§

type Output = <Wrapping<i128> as Sub<Wrapping<i128>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<i128> ) -> <Wrapping<i128> as Sub<Wrapping<i128>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<i128>> for Wrapping<i128>

§

type Output = <Wrapping<i128> as Sub<Wrapping<i128>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<i128> ) -> <Wrapping<i128> as Sub<Wrapping<i128>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<i16>> for &Wrapping<i16>

§

type Output = <Wrapping<i16> as Sub<Wrapping<i16>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<i16> ) -> <Wrapping<i16> as Sub<Wrapping<i16>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<i16>> for Wrapping<i16>

§

type Output = <Wrapping<i16> as Sub<Wrapping<i16>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<i16> ) -> <Wrapping<i16> as Sub<Wrapping<i16>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<i32>> for &Wrapping<i32>

§

type Output = <Wrapping<i32> as Sub<Wrapping<i32>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<i32> ) -> <Wrapping<i32> as Sub<Wrapping<i32>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<i32>> for Wrapping<i32>

§

type Output = <Wrapping<i32> as Sub<Wrapping<i32>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<i32> ) -> <Wrapping<i32> as Sub<Wrapping<i32>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<i64>> for &Wrapping<i64>

§

type Output = <Wrapping<i64> as Sub<Wrapping<i64>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<i64> ) -> <Wrapping<i64> as Sub<Wrapping<i64>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<i64>> for Wrapping<i64>

§

type Output = <Wrapping<i64> as Sub<Wrapping<i64>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<i64> ) -> <Wrapping<i64> as Sub<Wrapping<i64>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<i8>> for &Wrapping<i8>

§

type Output = <Wrapping<i8> as Sub<Wrapping<i8>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<i8> ) -> <Wrapping<i8> as Sub<Wrapping<i8>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<i8>> for Wrapping<i8>

§

type Output = <Wrapping<i8> as Sub<Wrapping<i8>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<i8> ) -> <Wrapping<i8> as Sub<Wrapping<i8>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<isize>> for &Wrapping<isize>

§

type Output = <Wrapping<isize> as Sub<Wrapping<isize>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<isize> ) -> <Wrapping<isize> as Sub<Wrapping<isize>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<isize>> for Wrapping<isize>

§

type Output = <Wrapping<isize> as Sub<Wrapping<isize>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<isize> ) -> <Wrapping<isize> as Sub<Wrapping<isize>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<u128>> for &Wrapping<u128>

§

type Output = <Wrapping<u128> as Sub<Wrapping<u128>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<u128> ) -> <Wrapping<u128> as Sub<Wrapping<u128>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<u128>> for Wrapping<u128>

§

type Output = <Wrapping<u128> as Sub<Wrapping<u128>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<u128> ) -> <Wrapping<u128> as Sub<Wrapping<u128>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<u16>> for &Wrapping<u16>

§

type Output = <Wrapping<u16> as Sub<Wrapping<u16>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<u16> ) -> <Wrapping<u16> as Sub<Wrapping<u16>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<u16>> for Wrapping<u16>

§

type Output = <Wrapping<u16> as Sub<Wrapping<u16>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<u16> ) -> <Wrapping<u16> as Sub<Wrapping<u16>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<u32>> for &Wrapping<u32>

§

type Output = <Wrapping<u32> as Sub<Wrapping<u32>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<u32> ) -> <Wrapping<u32> as Sub<Wrapping<u32>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<u32>> for Wrapping<u32>

§

type Output = <Wrapping<u32> as Sub<Wrapping<u32>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<u32> ) -> <Wrapping<u32> as Sub<Wrapping<u32>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<u64>> for &Wrapping<u64>

§

type Output = <Wrapping<u64> as Sub<Wrapping<u64>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<u64> ) -> <Wrapping<u64> as Sub<Wrapping<u64>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<u64>> for Wrapping<u64>

§

type Output = <Wrapping<u64> as Sub<Wrapping<u64>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<u64> ) -> <Wrapping<u64> as Sub<Wrapping<u64>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<u8>> for &Wrapping<u8>

§

type Output = <Wrapping<u8> as Sub<Wrapping<u8>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<u8> ) -> <Wrapping<u8> as Sub<Wrapping<u8>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<u8>> for Wrapping<u8>

§

type Output = <Wrapping<u8> as Sub<Wrapping<u8>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<u8> ) -> <Wrapping<u8> as Sub<Wrapping<u8>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<usize>> for &Wrapping<usize>

§

type Output = <Wrapping<usize> as Sub<Wrapping<usize>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<usize> ) -> <Wrapping<usize> as Sub<Wrapping<usize>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl Sub<&Wrapping<usize>> for Wrapping<usize>

§

type Output = <Wrapping<usize> as Sub<Wrapping<usize>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: &Wrapping<usize> ) -> <Wrapping<usize> as Sub<Wrapping<usize>>>::Output

执行 - 操作。 Read more
1.14.0 · source§

impl<'a> Sub<Wrapping<i128>> for &'a Wrapping<i128>

§

type Output = <Wrapping<i128> as Sub<Wrapping<i128>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: Wrapping<i128> ) -> <Wrapping<i128> as Sub<Wrapping<i128>>>::Output

执行 - 操作。 Read more
source§

impl Sub<Wrapping<i128>> for Wrapping<i128>

§

type Output = Wrapping<i128>

应用 - 运算符后的结果类型。
source§

fn sub(self, other: Wrapping<i128>) -> Wrapping<i128>

执行 - 操作。 Read more
1.14.0 · source§

impl<'a> Sub<Wrapping<i16>> for &'a Wrapping<i16>

§

type Output = <Wrapping<i16> as Sub<Wrapping<i16>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: Wrapping<i16> ) -> <Wrapping<i16> as Sub<Wrapping<i16>>>::Output

执行 - 操作。 Read more
source§

impl Sub<Wrapping<i16>> for Wrapping<i16>

§

type Output = Wrapping<i16>

应用 - 运算符后的结果类型。
source§

fn sub(self, other: Wrapping<i16>) -> Wrapping<i16>

执行 - 操作。 Read more
1.14.0 · source§

impl<'a> Sub<Wrapping<i32>> for &'a Wrapping<i32>

§

type Output = <Wrapping<i32> as Sub<Wrapping<i32>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: Wrapping<i32> ) -> <Wrapping<i32> as Sub<Wrapping<i32>>>::Output

执行 - 操作。 Read more
source§

impl Sub<Wrapping<i32>> for Wrapping<i32>

§

type Output = Wrapping<i32>

应用 - 运算符后的结果类型。
source§

fn sub(self, other: Wrapping<i32>) -> Wrapping<i32>

执行 - 操作。 Read more
1.14.0 · source§

impl<'a> Sub<Wrapping<i64>> for &'a Wrapping<i64>

§

type Output = <Wrapping<i64> as Sub<Wrapping<i64>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: Wrapping<i64> ) -> <Wrapping<i64> as Sub<Wrapping<i64>>>::Output

执行 - 操作。 Read more
source§

impl Sub<Wrapping<i64>> for Wrapping<i64>

§

type Output = Wrapping<i64>

应用 - 运算符后的结果类型。
source§

fn sub(self, other: Wrapping<i64>) -> Wrapping<i64>

执行 - 操作。 Read more
1.14.0 · source§

impl<'a> Sub<Wrapping<i8>> for &'a Wrapping<i8>

§

type Output = <Wrapping<i8> as Sub<Wrapping<i8>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub(self, other: Wrapping<i8>) -> <Wrapping<i8> as Sub<Wrapping<i8>>>::Output

执行 - 操作。 Read more
source§

impl Sub<Wrapping<i8>> for Wrapping<i8>

§

type Output = Wrapping<i8>

应用 - 运算符后的结果类型。
source§

fn sub(self, other: Wrapping<i8>) -> Wrapping<i8>

执行 - 操作。 Read more
1.14.0 · source§

impl<'a> Sub<Wrapping<isize>> for &'a Wrapping<isize>

§

type Output = <Wrapping<isize> as Sub<Wrapping<isize>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: Wrapping<isize> ) -> <Wrapping<isize> as Sub<Wrapping<isize>>>::Output

执行 - 操作。 Read more
source§

impl Sub<Wrapping<isize>> for Wrapping<isize>

§

type Output = Wrapping<isize>

应用 - 运算符后的结果类型。
source§

fn sub(self, other: Wrapping<isize>) -> Wrapping<isize>

执行 - 操作。 Read more
1.14.0 · source§

impl<'a> Sub<Wrapping<u128>> for &'a Wrapping<u128>

§

type Output = <Wrapping<u128> as Sub<Wrapping<u128>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: Wrapping<u128> ) -> <Wrapping<u128> as Sub<Wrapping<u128>>>::Output

执行 - 操作。 Read more
source§

impl Sub<Wrapping<u128>> for Wrapping<u128>

§

type Output = Wrapping<u128>

应用 - 运算符后的结果类型。
source§

fn sub(self, other: Wrapping<u128>) -> Wrapping<u128>

执行 - 操作。 Read more
1.14.0 · source§

impl<'a> Sub<Wrapping<u16>> for &'a Wrapping<u16>

§

type Output = <Wrapping<u16> as Sub<Wrapping<u16>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: Wrapping<u16> ) -> <Wrapping<u16> as Sub<Wrapping<u16>>>::Output

执行 - 操作。 Read more
source§

impl Sub<Wrapping<u16>> for Wrapping<u16>

§

type Output = Wrapping<u16>

应用 - 运算符后的结果类型。
source§

fn sub(self, other: Wrapping<u16>) -> Wrapping<u16>

执行 - 操作。 Read more
1.14.0 · source§

impl<'a> Sub<Wrapping<u32>> for &'a Wrapping<u32>

§

type Output = <Wrapping<u32> as Sub<Wrapping<u32>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: Wrapping<u32> ) -> <Wrapping<u32> as Sub<Wrapping<u32>>>::Output

执行 - 操作。 Read more
source§

impl Sub<Wrapping<u32>> for Wrapping<u32>

§

type Output = Wrapping<u32>

应用 - 运算符后的结果类型。
source§

fn sub(self, other: Wrapping<u32>) -> Wrapping<u32>

执行 - 操作。 Read more
1.14.0 · source§

impl<'a> Sub<Wrapping<u64>> for &'a Wrapping<u64>

§

type Output = <Wrapping<u64> as Sub<Wrapping<u64>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: Wrapping<u64> ) -> <Wrapping<u64> as Sub<Wrapping<u64>>>::Output

执行 - 操作。 Read more
source§

impl Sub<Wrapping<u64>> for Wrapping<u64>

§

type Output = Wrapping<u64>

应用 - 运算符后的结果类型。
source§

fn sub(self, other: Wrapping<u64>) -> Wrapping<u64>

执行 - 操作。 Read more
1.14.0 · source§

impl<'a> Sub<Wrapping<u8>> for &'a Wrapping<u8>

§

type Output = <Wrapping<u8> as Sub<Wrapping<u8>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub(self, other: Wrapping<u8>) -> <Wrapping<u8> as Sub<Wrapping<u8>>>::Output

执行 - 操作。 Read more
source§

impl Sub<Wrapping<u8>> for Wrapping<u8>

§

type Output = Wrapping<u8>

应用 - 运算符后的结果类型。
source§

fn sub(self, other: Wrapping<u8>) -> Wrapping<u8>

执行 - 操作。 Read more
1.14.0 · source§

impl<'a> Sub<Wrapping<usize>> for &'a Wrapping<usize>

§

type Output = <Wrapping<usize> as Sub<Wrapping<usize>>>::Output

应用 - 运算符后的结果类型。
source§

fn sub( self, other: Wrapping<usize> ) -> <Wrapping<usize> as Sub<Wrapping<usize>>>::Output

执行 - 操作。 Read more
source§

impl Sub<Wrapping<usize>> for Wrapping<usize>

§

type Output = Wrapping<usize>

应用 - 运算符后的结果类型。
source§

fn sub(self, other: Wrapping<usize>) -> Wrapping<usize>

执行 - 操作。 Read more
1.22.0 · source§

impl SubAssign<&Wrapping<i128>> for Wrapping<i128>

source§

fn sub_assign(&mut self, other: &Wrapping<i128>)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&Wrapping<i16>> for Wrapping<i16>

source§

fn sub_assign(&mut self, other: &Wrapping<i16>)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&Wrapping<i32>> for Wrapping<i32>

source§

fn sub_assign(&mut self, other: &Wrapping<i32>)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&Wrapping<i64>> for Wrapping<i64>

source§

fn sub_assign(&mut self, other: &Wrapping<i64>)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&Wrapping<i8>> for Wrapping<i8>

source§

fn sub_assign(&mut self, other: &Wrapping<i8>)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&Wrapping<isize>> for Wrapping<isize>

source§

fn sub_assign(&mut self, other: &Wrapping<isize>)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&Wrapping<u128>> for Wrapping<u128>

source§

fn sub_assign(&mut self, other: &Wrapping<u128>)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&Wrapping<u16>> for Wrapping<u16>

source§

fn sub_assign(&mut self, other: &Wrapping<u16>)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&Wrapping<u32>> for Wrapping<u32>

source§

fn sub_assign(&mut self, other: &Wrapping<u32>)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&Wrapping<u64>> for Wrapping<u64>

source§

fn sub_assign(&mut self, other: &Wrapping<u64>)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&Wrapping<u8>> for Wrapping<u8>

source§

fn sub_assign(&mut self, other: &Wrapping<u8>)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&Wrapping<usize>> for Wrapping<usize>

source§

fn sub_assign(&mut self, other: &Wrapping<usize>)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&i128> for Wrapping<i128>

source§

fn sub_assign(&mut self, other: &i128)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&i16> for Wrapping<i16>

source§

fn sub_assign(&mut self, other: &i16)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&i32> for Wrapping<i32>

source§

fn sub_assign(&mut self, other: &i32)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&i64> for Wrapping<i64>

source§

fn sub_assign(&mut self, other: &i64)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&i8> for Wrapping<i8>

source§

fn sub_assign(&mut self, other: &i8)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&isize> for Wrapping<isize>

source§

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

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&u128> for Wrapping<u128>

source§

fn sub_assign(&mut self, other: &u128)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&u16> for Wrapping<u16>

source§

fn sub_assign(&mut self, other: &u16)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&u32> for Wrapping<u32>

source§

fn sub_assign(&mut self, other: &u32)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&u64> for Wrapping<u64>

source§

fn sub_assign(&mut self, other: &u64)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&u8> for Wrapping<u8>

source§

fn sub_assign(&mut self, other: &u8)

执行 -= 操作。 Read more
1.22.0 · source§

impl SubAssign<&usize> for Wrapping<usize>

source§

fn sub_assign(&mut self, other: &usize)

执行 -= 操作。 Read more
1.8.0 · source§

impl SubAssign<Wrapping<i128>> for Wrapping<i128>

source§

fn sub_assign(&mut self, other: Wrapping<i128>)

执行 -= 操作。 Read more
1.8.0 · source§

impl SubAssign<Wrapping<i16>> for Wrapping<i16>

source§

fn sub_assign(&mut self, other: Wrapping<i16>)

执行 -= 操作。 Read more
1.8.0 · source§

impl SubAssign<Wrapping<i32>> for Wrapping<i32>

source§

fn sub_assign(&mut self, other: Wrapping<i32>)

执行 -= 操作。 Read more
1.8.0 · source§

impl SubAssign<Wrapping<i64>> for Wrapping<i64>

source§

fn sub_assign(&mut self, other: Wrapping<i64>)

执行 -= 操作。 Read more
1.8.0 · source§

impl SubAssign<Wrapping<i8>> for Wrapping<i8>

source§

fn sub_assign(&mut self, other: Wrapping<i8>)

执行 -= 操作。 Read more
1.8.0 · source§

impl SubAssign<Wrapping<isize>> for Wrapping<isize>

source§

fn sub_assign(&mut self, other: Wrapping<isize>)

执行 -= 操作。 Read more
1.8.0 · source§

impl SubAssign<Wrapping<u128>> for Wrapping<u128>

source§

fn sub_assign(&mut self, other: Wrapping<u128>)

执行 -= 操作。 Read more
1.8.0 · source§

impl SubAssign<Wrapping<u16>> for Wrapping<u16>

source§

fn sub_assign(&mut self, other: Wrapping<u16>)

执行 -= 操作。 Read more
1.8.0 · source§

impl SubAssign<Wrapping<u32>> for Wrapping<u32>

source§

fn sub_assign(&mut self, other: Wrapping<u32>)

执行 -= 操作。 Read more
1.8.0 · source§

impl SubAssign<Wrapping<u64>> for Wrapping<u64>

source§

fn sub_assign(&mut self, other: Wrapping<u64>)

执行 -= 操作。 Read more
1.8.0 · source§

impl SubAssign<Wrapping<u8>> for Wrapping<u8>

source§

fn sub_assign(&mut self, other: Wrapping<u8>)

执行 -= 操作。 Read more
1.8.0 · source§

impl SubAssign<Wrapping<usize>> for Wrapping<usize>

source§

fn sub_assign(&mut self, other: Wrapping<usize>)

执行 -= 操作。 Read more
1.60.0 · source§

impl SubAssign<i128> for Wrapping<i128>

source§

fn sub_assign(&mut self, other: i128)

执行 -= 操作。 Read more
1.60.0 · source§

impl SubAssign<i16> for Wrapping<i16>

source§

fn sub_assign(&mut self, other: i16)

执行 -= 操作。 Read more
1.60.0 · source§

impl SubAssign<i32> for Wrapping<i32>

source§

fn sub_assign(&mut self, other: i32)

执行 -= 操作。 Read more
1.60.0 · source§

impl SubAssign<i64> for Wrapping<i64>

source§

fn sub_assign(&mut self, other: i64)

执行 -= 操作。 Read more
1.60.0 · source§

impl SubAssign<i8> for Wrapping<i8>

source§

fn sub_assign(&mut self, other: i8)

执行 -= 操作。 Read more
1.60.0 · source§

impl SubAssign<isize> for Wrapping<isize>

source§

fn sub_assign(&mut self, other: isize)

执行 -= 操作。 Read more
1.60.0 · source§

impl SubAssign<u128> for Wrapping<u128>

source§

fn sub_assign(&mut self, other: u128)

执行 -= 操作。 Read more
1.60.0 · source§

impl SubAssign<u16> for Wrapping<u16>

source§

fn sub_assign(&mut self, other: u16)

执行 -= 操作。 Read more
1.60.0 · source§

impl SubAssign<u32> for Wrapping<u32>

source§

fn sub_assign(&mut self, other: u32)

执行 -= 操作。 Read more
1.60.0 · source§

impl SubAssign<u64> for Wrapping<u64>

source§

fn sub_assign(&mut self, other: u64)

执行 -= 操作。 Read more
1.60.0 · source§

impl SubAssign<u8> for Wrapping<u8>

source§

fn sub_assign(&mut self, other: u8)

执行 -= 操作。 Read more
1.60.0 · source§

impl SubAssign<usize> for Wrapping<usize>

source§

fn sub_assign(&mut self, other: usize)

执行 -= 操作。 Read more
1.14.0 · source§

impl<'a> Sum<&'a Wrapping<i128>> for Wrapping<i128>

source§

fn sum<I>(iter: I) -> Wrapping<i128>where I: Iterator<Item = &'a Wrapping<i128>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl<'a> Sum<&'a Wrapping<i16>> for Wrapping<i16>

source§

fn sum<I>(iter: I) -> Wrapping<i16>where I: Iterator<Item = &'a Wrapping<i16>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl<'a> Sum<&'a Wrapping<i32>> for Wrapping<i32>

source§

fn sum<I>(iter: I) -> Wrapping<i32>where I: Iterator<Item = &'a Wrapping<i32>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl<'a> Sum<&'a Wrapping<i64>> for Wrapping<i64>

source§

fn sum<I>(iter: I) -> Wrapping<i64>where I: Iterator<Item = &'a Wrapping<i64>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl<'a> Sum<&'a Wrapping<i8>> for Wrapping<i8>

source§

fn sum<I>(iter: I) -> Wrapping<i8>where I: Iterator<Item = &'a Wrapping<i8>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl<'a> Sum<&'a Wrapping<isize>> for Wrapping<isize>

source§

fn sum<I>(iter: I) -> Wrapping<isize>where I: Iterator<Item = &'a Wrapping<isize>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl<'a> Sum<&'a Wrapping<u128>> for Wrapping<u128>

source§

fn sum<I>(iter: I) -> Wrapping<u128>where I: Iterator<Item = &'a Wrapping<u128>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl<'a> Sum<&'a Wrapping<u16>> for Wrapping<u16>

source§

fn sum<I>(iter: I) -> Wrapping<u16>where I: Iterator<Item = &'a Wrapping<u16>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl<'a> Sum<&'a Wrapping<u32>> for Wrapping<u32>

source§

fn sum<I>(iter: I) -> Wrapping<u32>where I: Iterator<Item = &'a Wrapping<u32>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl<'a> Sum<&'a Wrapping<u64>> for Wrapping<u64>

source§

fn sum<I>(iter: I) -> Wrapping<u64>where I: Iterator<Item = &'a Wrapping<u64>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl<'a> Sum<&'a Wrapping<u8>> for Wrapping<u8>

source§

fn sum<I>(iter: I) -> Wrapping<u8>where I: Iterator<Item = &'a Wrapping<u8>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl<'a> Sum<&'a Wrapping<usize>> for Wrapping<usize>

source§

fn sum<I>(iter: I) -> Wrapping<usize>where I: Iterator<Item = &'a Wrapping<usize>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl Sum<Wrapping<i128>> for Wrapping<i128>

source§

fn sum<I>(iter: I) -> Wrapping<i128>where I: Iterator<Item = Wrapping<i128>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl Sum<Wrapping<i16>> for Wrapping<i16>

source§

fn sum<I>(iter: I) -> Wrapping<i16>where I: Iterator<Item = Wrapping<i16>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl Sum<Wrapping<i32>> for Wrapping<i32>

source§

fn sum<I>(iter: I) -> Wrapping<i32>where I: Iterator<Item = Wrapping<i32>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl Sum<Wrapping<i64>> for Wrapping<i64>

source§

fn sum<I>(iter: I) -> Wrapping<i64>where I: Iterator<Item = Wrapping<i64>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl Sum<Wrapping<i8>> for Wrapping<i8>

source§

fn sum<I>(iter: I) -> Wrapping<i8>where I: Iterator<Item = Wrapping<i8>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl Sum<Wrapping<isize>> for Wrapping<isize>

source§

fn sum<I>(iter: I) -> Wrapping<isize>where I: Iterator<Item = Wrapping<isize>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl Sum<Wrapping<u128>> for Wrapping<u128>

source§

fn sum<I>(iter: I) -> Wrapping<u128>where I: Iterator<Item = Wrapping<u128>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl Sum<Wrapping<u16>> for Wrapping<u16>

source§

fn sum<I>(iter: I) -> Wrapping<u16>where I: Iterator<Item = Wrapping<u16>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl Sum<Wrapping<u32>> for Wrapping<u32>

source§

fn sum<I>(iter: I) -> Wrapping<u32>where I: Iterator<Item = Wrapping<u32>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl Sum<Wrapping<u64>> for Wrapping<u64>

source§

fn sum<I>(iter: I) -> Wrapping<u64>where I: Iterator<Item = Wrapping<u64>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl Sum<Wrapping<u8>> for Wrapping<u8>

source§

fn sum<I>(iter: I) -> Wrapping<u8>where I: Iterator<Item = Wrapping<u8>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.14.0 · source§

impl Sum<Wrapping<usize>> for Wrapping<usize>

source§

fn sum<I>(iter: I) -> Wrapping<usize>where I: Iterator<Item = Wrapping<usize>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.11.0 · source§

impl<T> UpperHex for Wrapping<T>where T: UpperHex,

source§

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

使用给定的格式化程序格式化该值。
source§

impl<T> Copy for Wrapping<T>where T: Copy,

source§

impl<T> Eq for Wrapping<T>where T: Eq,

source§

impl<T> StructuralEq for Wrapping<T>

source§

impl<T> StructuralPartialEq for Wrapping<T>

Auto Trait Implementations§

§

impl<T> RefUnwindSafe for Wrapping<T>where T: RefUnwindSafe,

§

impl<T> Send for Wrapping<T>where T: Send,

§

impl<T> Sync for Wrapping<T>where T: Sync,

§

impl<T> Unpin for Wrapping<T>where T: Unpin,

§

impl<T> UnwindSafe for Wrapping<T>where T: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

获取 selfTypeIdRead more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

从拥有的值中一成不变地借用。 Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

从拥有的值中借用。 Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

返回未更改的参数。

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

调用 U::from(self)

也就是说,这种转换是 From<T> for U 实现选择执行的任何操作。

source§

impl<T> ToOwned for Twhere T: Clone,

§

type Owned = T

获得所有权后的结果类型。
source§

fn to_owned(&self) -> T

从借用的数据创建拥有的数据,通常是通过克隆。 Read more
source§

fn clone_into(&self, target: &mut T)

使用借来的数据来替换拥有的数据,通常是通过克隆。 Read more
source§

impl<T> ToString for Twhere T: Display + ?Sized,

source§

default fn to_string(&self) -> String

将给定值转换为 StringRead more
source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

发生转换错误时返回的类型。
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

执行转换。
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

发生转换错误时返回的类型。
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

执行转换。