Trait ExtNumConst

pub trait ExtNumConst {
    type Num;

    const NUM_ZERO: Option<Self::Num>;
    const NUM_ONE: Self::Num;
    const NUM_TWO: Self::Num;
    const NUM_THREE: Self::Num;
    const NUM_NEG_ONE: Option<Self::Num>;
    const NUM_MIN_POSITIVE: Self::Num;
    const NUM_MAX_NEGATIVE: Option<Self::Num>;
    const NUM_MAX_POWER_OF_TWO: Self::Num;
}

Fundamental numeric constants for both integer and floating-point types.

Required Associated Constants

const NUM_ZERO: Option<Self::Num>

The additive identity (0), if applicable.

const NUM_ONE: Self::Num

The multiplicative identity (1).

const NUM_TWO: Self::Num

The only even prime and the fundamental doubling factor (2).

const NUM_THREE: Self::Num

The smallest odd prime and the first nontrivial divisor (3).

const NUM_NEG_ONE: Option<Self::Num>

The additive inverse of ONE (-1), if applicable.

const NUM_MIN_POSITIVE: Self::Num

The smallest representable positive value.

const NUM_MAX_NEGATIVE: Option<Self::Num>

The greatest representable negative value, if applicable.

const NUM_MAX_POWER_OF_TWO: Self::Num

The maximum power of two within the type’s range.

Required Associated Types

type Num

The underlying numeric type implementing this trait.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl ExtNumConst for f32

const NUM_ZERO: Option<f32>

const NUM_ONE: f32 = 1f32

const NUM_TWO: f32 = 2f32

const NUM_THREE: f32 = 3f32

const NUM_NEG_ONE: Option<f32>

const NUM_MIN_POSITIVE: f32 = 1.17549435E-38f32

const NUM_MAX_NEGATIVE: Option<f32>

const NUM_MAX_POWER_OF_TWO: f32 = 1.70141183E+38f32

type Num = f32

impl ExtNumConst for f64

const NUM_ZERO: Option<f64>

const NUM_ONE: f64 = 1f64

const NUM_TWO: f64 = 2f64

const NUM_THREE: f64 = 3f64

const NUM_NEG_ONE: Option<f64>

const NUM_MIN_POSITIVE: f64 = 2.2250738585072014E-308f64

const NUM_MAX_NEGATIVE: Option<f64>

const NUM_MAX_POWER_OF_TWO: f64 = 8.9884656743115795E+307f64

type Num = f64

impl ExtNumConst for i8

const NUM_ZERO: Option<i8>

const NUM_ONE: i8 = 1i8

const NUM_TWO: i8 = 2i8

const NUM_THREE: i8 = 3i8

const NUM_NEG_ONE: Option<i8>

const NUM_MIN_POSITIVE: i8 = 1i8

const NUM_MAX_NEGATIVE: Option<i8>

const NUM_MAX_POWER_OF_TWO: i8 = 64i8

type Num = i8

impl ExtNumConst for i16

const NUM_ZERO: Option<i16>

const NUM_ONE: i16 = 1i16

const NUM_TWO: i16 = 2i16

const NUM_THREE: i16 = 3i16

const NUM_NEG_ONE: Option<i16>

const NUM_MIN_POSITIVE: i16 = 1i16

const NUM_MAX_NEGATIVE: Option<i16>

const NUM_MAX_POWER_OF_TWO: i16 = 16_384i16

type Num = i16

impl ExtNumConst for i32

const NUM_ZERO: Option<i32>

const NUM_ONE: i32 = 1i32

const NUM_TWO: i32 = 2i32

const NUM_THREE: i32 = 3i32

const NUM_NEG_ONE: Option<i32>

const NUM_MIN_POSITIVE: i32 = 1i32

const NUM_MAX_NEGATIVE: Option<i32>

const NUM_MAX_POWER_OF_TWO: i32 = 1_073_741_824i32

type Num = i32

impl ExtNumConst for i64

const NUM_ZERO: Option<i64>

const NUM_ONE: i64 = 1i64

const NUM_TWO: i64 = 2i64

const NUM_THREE: i64 = 3i64

const NUM_NEG_ONE: Option<i64>

const NUM_MIN_POSITIVE: i64 = 1i64

const NUM_MAX_NEGATIVE: Option<i64>

const NUM_MAX_POWER_OF_TWO: i64 = 4_611_686_018_427_387_904i64

type Num = i64

impl ExtNumConst for i128

const NUM_ZERO: Option<i128>

const NUM_ONE: i128 = 1i128

const NUM_TWO: i128 = 2i128

const NUM_THREE: i128 = 3i128

const NUM_NEG_ONE: Option<i128>

const NUM_MIN_POSITIVE: i128 = 1i128

const NUM_MAX_NEGATIVE: Option<i128>

const NUM_MAX_POWER_OF_TWO: i128 = 85_070_591_730_234_615_865_843_651_857_942_052_864i128

type Num = i128

impl ExtNumConst for isize

const NUM_ZERO: Option<isize>

const NUM_ONE: isize = 1isize

const NUM_TWO: isize = 2isize

const NUM_THREE: isize = 3isize

const NUM_NEG_ONE: Option<isize>

const NUM_MIN_POSITIVE: isize = 1isize

const NUM_MAX_NEGATIVE: Option<isize>

const NUM_MAX_POWER_OF_TWO: isize = 4_611_686_018_427_387_904isize

type Num = isize

impl ExtNumConst for u8

const NUM_ZERO: Option<u8>

const NUM_ONE: u8 = 1u8

const NUM_TWO: u8 = 2u8

const NUM_THREE: u8 = 3u8

const NUM_NEG_ONE: Option<u8> = None

const NUM_MIN_POSITIVE: u8 = 1u8

const NUM_MAX_NEGATIVE: Option<u8> = None

const NUM_MAX_POWER_OF_TWO: u8 = 128u8

type Num = u8

impl ExtNumConst for u16

const NUM_ZERO: Option<u16>

const NUM_ONE: u16 = 1u16

const NUM_TWO: u16 = 2u16

const NUM_THREE: u16 = 3u16

const NUM_NEG_ONE: Option<u16> = None

const NUM_MIN_POSITIVE: u16 = 1u16

const NUM_MAX_NEGATIVE: Option<u16> = None

const NUM_MAX_POWER_OF_TWO: u16 = 32_768u16

type Num = u16

impl ExtNumConst for u32

const NUM_ZERO: Option<u32>

const NUM_ONE: u32 = 1u32

const NUM_TWO: u32 = 2u32

const NUM_THREE: u32 = 3u32

const NUM_NEG_ONE: Option<u32> = None

const NUM_MIN_POSITIVE: u32 = 1u32

const NUM_MAX_NEGATIVE: Option<u32> = None

const NUM_MAX_POWER_OF_TWO: u32 = 2_147_483_648u32

type Num = u32

impl ExtNumConst for u64

const NUM_ZERO: Option<u64>

const NUM_ONE: u64 = 1u64

const NUM_TWO: u64 = 2u64

const NUM_THREE: u64 = 3u64

const NUM_NEG_ONE: Option<u64> = None

const NUM_MIN_POSITIVE: u64 = 1u64

const NUM_MAX_NEGATIVE: Option<u64> = None

const NUM_MAX_POWER_OF_TWO: u64 = 9_223_372_036_854_775_808u64

type Num = u64

impl ExtNumConst for u128

const NUM_ZERO: Option<u128>

const NUM_ONE: u128 = 1u128

const NUM_TWO: u128 = 2u128

const NUM_THREE: u128 = 3u128

const NUM_NEG_ONE: Option<u128> = None

const NUM_MIN_POSITIVE: u128 = 1u128

const NUM_MAX_NEGATIVE: Option<u128> = None

const NUM_MAX_POWER_OF_TWO: u128 = 170_141_183_460_469_231_731_687_303_715_884_105_728u128

type Num = u128

impl ExtNumConst for usize

const NUM_ZERO: Option<usize>

const NUM_ONE: usize = 1usize

const NUM_TWO: usize = 2usize

const NUM_THREE: usize = 3usize

const NUM_NEG_ONE: Option<usize> = None

const NUM_MIN_POSITIVE: usize = 1usize

const NUM_MAX_NEGATIVE: Option<usize> = None

const NUM_MAX_POWER_OF_TWO: usize = 9_223_372_036_854_775_808usize

type Num = usize

Implementors

impl ExtNumConst for NonZeroI8

const NUM_ZERO: Option<NonZeroI8> = None

const NUM_ONE: NonZeroI8

const NUM_TWO: NonZeroI8

const NUM_THREE: NonZeroI8

const NUM_NEG_ONE: Option<NonZeroI8>

const NUM_MIN_POSITIVE: NonZeroI8

const NUM_MAX_NEGATIVE: Option<NonZeroI8>

const NUM_MAX_POWER_OF_TWO: NonZeroI8

type Num = NonZero<i8>

impl ExtNumConst for NonZeroI16

const NUM_ZERO: Option<NonZeroI16> = None

const NUM_ONE: NonZeroI16

const NUM_TWO: NonZeroI16

const NUM_THREE: NonZeroI16

const NUM_NEG_ONE: Option<NonZeroI16>

const NUM_MIN_POSITIVE: NonZeroI16

const NUM_MAX_NEGATIVE: Option<NonZeroI16>

const NUM_MAX_POWER_OF_TWO: NonZeroI16

type Num = NonZero<i16>

impl ExtNumConst for NonZeroI32

const NUM_ZERO: Option<NonZeroI32> = None

const NUM_ONE: NonZeroI32

const NUM_TWO: NonZeroI32

const NUM_THREE: NonZeroI32

const NUM_NEG_ONE: Option<NonZeroI32>

const NUM_MIN_POSITIVE: NonZeroI32

const NUM_MAX_NEGATIVE: Option<NonZeroI32>

const NUM_MAX_POWER_OF_TWO: NonZeroI32

type Num = NonZero<i32>

impl ExtNumConst for NonZeroI64

const NUM_ZERO: Option<NonZeroI64> = None

const NUM_ONE: NonZeroI64

const NUM_TWO: NonZeroI64

const NUM_THREE: NonZeroI64

const NUM_NEG_ONE: Option<NonZeroI64>

const NUM_MIN_POSITIVE: NonZeroI64

const NUM_MAX_NEGATIVE: Option<NonZeroI64>

const NUM_MAX_POWER_OF_TWO: NonZeroI64

type Num = NonZero<i64>

impl ExtNumConst for NonZeroI128

const NUM_ZERO: Option<NonZeroI128> = None

const NUM_ONE: NonZeroI128

const NUM_TWO: NonZeroI128

const NUM_THREE: NonZeroI128

const NUM_NEG_ONE: Option<NonZeroI128>

const NUM_MIN_POSITIVE: NonZeroI128

const NUM_MAX_NEGATIVE: Option<NonZeroI128>

const NUM_MAX_POWER_OF_TWO: NonZeroI128

type Num = NonZero<i128>

impl ExtNumConst for NonZeroIsize

const NUM_ZERO: Option<NonZeroIsize> = None

const NUM_ONE: NonZeroIsize

const NUM_TWO: NonZeroIsize

const NUM_THREE: NonZeroIsize

const NUM_NEG_ONE: Option<NonZeroIsize>

const NUM_MIN_POSITIVE: NonZeroIsize

const NUM_MAX_NEGATIVE: Option<NonZeroIsize>

const NUM_MAX_POWER_OF_TWO: NonZeroIsize

type Num = NonZero<isize>

impl ExtNumConst for NonZeroU8

const NUM_ZERO: Option<NonZeroU8> = None

const NUM_ONE: NonZeroU8

const NUM_TWO: NonZeroU8

const NUM_THREE: NonZeroU8

const NUM_NEG_ONE: Option<NonZeroU8> = None

const NUM_MIN_POSITIVE: NonZeroU8

const NUM_MAX_NEGATIVE: Option<NonZeroU8> = None

const NUM_MAX_POWER_OF_TWO: NonZeroU8

type Num = NonZero<u8>

impl ExtNumConst for NonZeroU16

const NUM_ZERO: Option<NonZeroU16> = None

const NUM_ONE: NonZeroU16

const NUM_TWO: NonZeroU16

const NUM_THREE: NonZeroU16

const NUM_NEG_ONE: Option<NonZeroU16> = None

const NUM_MIN_POSITIVE: NonZeroU16

const NUM_MAX_NEGATIVE: Option<NonZeroU16> = None

const NUM_MAX_POWER_OF_TWO: NonZeroU16

type Num = NonZero<u16>

impl ExtNumConst for NonZeroU32

const NUM_ZERO: Option<NonZeroU32> = None

const NUM_ONE: NonZeroU32

const NUM_TWO: NonZeroU32

const NUM_THREE: NonZeroU32

const NUM_NEG_ONE: Option<NonZeroU32> = None

const NUM_MIN_POSITIVE: NonZeroU32

const NUM_MAX_NEGATIVE: Option<NonZeroU32> = None

const NUM_MAX_POWER_OF_TWO: NonZeroU32

type Num = NonZero<u32>

impl ExtNumConst for NonZeroU64

const NUM_ZERO: Option<NonZeroU64> = None

const NUM_ONE: NonZeroU64

const NUM_TWO: NonZeroU64

const NUM_THREE: NonZeroU64

const NUM_NEG_ONE: Option<NonZeroU64> = None

const NUM_MIN_POSITIVE: NonZeroU64

const NUM_MAX_NEGATIVE: Option<NonZeroU64> = None

const NUM_MAX_POWER_OF_TWO: NonZeroU64

type Num = NonZero<u64>

impl ExtNumConst for NonZeroU128

const NUM_ZERO: Option<NonZeroU128> = None

const NUM_ONE: NonZeroU128

const NUM_TWO: NonZeroU128

const NUM_THREE: NonZeroU128

const NUM_NEG_ONE: Option<NonZeroU128> = None

const NUM_MIN_POSITIVE: NonZeroU128

const NUM_MAX_NEGATIVE: Option<NonZeroU128> = None

const NUM_MAX_POWER_OF_TWO: NonZeroU128

type Num = NonZero<u128>

impl ExtNumConst for NonZeroUsize

const NUM_ZERO: Option<NonZeroUsize> = None

const NUM_ONE: NonZeroUsize

const NUM_TWO: NonZeroUsize

const NUM_THREE: NonZeroUsize

const NUM_NEG_ONE: Option<NonZeroUsize> = None

const NUM_MIN_POSITIVE: NonZeroUsize

const NUM_MAX_NEGATIVE: Option<NonZeroUsize> = None

const NUM_MAX_POWER_OF_TWO: NonZeroUsize

type Num = NonZero<usize>