Enum Number 

pub enum Number {
    F32(f32),
    F64(f64),
    I128(i128),
    I16(i16),
    I32(i32),
    I64(i64),
    I8(i8),
    Isize(isize),
    U128(u128),
    U16(u16),
    U32(u32),
    U64(u64),
    U8(u8),
    Usize(usize),
}

Represents a generic number that maintains an internal Rust representation of the actual number

Variants

F32(f32)

F64(f64)

I128(i128)

I16(i16)

I32(i32)

I64(i64)

I8(i8)

Isize(isize)

U128(u128)

U16(u16)

U32(u32)

U64(u64)

U8(u8)

Usize(usize)

Implementations

impl Number

pub fn sign(&self) -> NumberSign

Returns an indicator of the sign (negative, zero, positive) of this number

use entity::{Number, NumberSign};

assert_eq!(Number::from(0).sign(), NumberSign::Zero);
assert_eq!(Number::from(99).sign(), NumberSign::Positive);
assert_eq!(Number::from(-99).sign(), NumberSign::Negative);

pub fn is_zero(&self) -> bool

Returns true if number is zero (not negative or positive)

use entity::Number;

assert!(Number::from(0).is_zero());
assert!(!Number::from(1).is_zero());
assert!(!Number::from(-1).is_zero());

pub fn is_positive(&self) -> bool

Returns true if number is positive (not zero or negative)

Examples

use entity::Number;

assert!(Number::from(1).is_positive());
assert!(!Number::from(0).is_positive());
assert!(!Number::from(-1).is_positive());

pub fn is_negative(&self) -> bool

Returns true if number is negative (not zero or positive)

Examples

use entity::Number;

assert!(Number::from(-1).is_negative());
assert!(!Number::from(0).is_negative());
assert!(!Number::from(1).is_negative());

pub fn is_signed(&self) -> bool

Returns true if number is a signed integer

Examples

use entity::Number;

assert!(Number::from(3isize).is_signed());
assert!(!Number::from(3usize).is_signed());

pub fn is_unsigned(&self) -> bool

Returns true if number is an unsigned integer

Examples

use entity::Number;

assert!(Number::from(3usize).is_unsigned());
assert!(!Number::from(3isize).is_unsigned());

pub fn is_float(&self) -> bool

Returns true if number is a float

Examples

use entity::Number;

assert!(Number::from(3f32).is_float());
assert!(!Number::from(3usize).is_float());

pub fn has_nonzero_fraction(&self) -> bool

Returns true if number is a float with a non-zero fractional part

Examples

use entity::Number;

assert!(Number::from(3.1).has_nonzero_fraction());
assert!(!Number::from(3.0).has_nonzero_fraction());

pub fn is_normal(&self) -> bool

Returns true if number is neither zero, infinite, subnormal, or NaN

Examples

use entity::Number;

assert!(Number::from(1).is_normal());
assert!(Number::from(0.1).is_normal());
assert!(!Number::from(0).is_normal());
assert!(!Number::from(f64::NAN).is_normal());
assert!(!Number::from(f64::INFINITY).is_normal());
assert!(!Number::from(f64::NEG_INFINITY).is_normal());
assert!(!Number::from(1.0e-308_f64).is_normal());

pub fn to_absolute(&self) -> Self

Returns a conversion of the underlying number to an absolute version of itself

pub fn to_f64(&self) -> f64

Naive casting of number’s inner representation to f64by performing x as f64

pub fn to_f32(&self) -> f32

Naive casting of number’s inner representation to f32by performing x as f32

pub fn to_isize(&self) -> isize

Naive casting of number’s inner representation to isizeby performing x as isize

pub fn to_i128(&self) -> i128

Naive casting of number’s inner representation to i128by performing x as i128

pub fn to_i64(&self) -> i64

Naive casting of number’s inner representation to i64by performing x as i64

pub fn to_i32(&self) -> i32

Naive casting of number’s inner representation to i32by performing x as i32

pub fn to_i16(&self) -> i16

Naive casting of number’s inner representation to i16by performing x as i16

pub fn to_i8(&self) -> i8

Naive casting of number’s inner representation to i8by performing x as i8

pub fn to_usize(&self) -> usize

Naive casting of number’s inner representation to usizeby performing x as usize

pub fn to_u128(&self) -> u128

Naive casting of number’s inner representation to u128by performing x as u128

pub fn to_u64(&self) -> u64

Naive casting of number’s inner representation to u64by performing x as u64

pub fn to_u32(&self) -> u32

Naive casting of number’s inner representation to u32by performing x as u32

pub fn to_u16(&self) -> u16

Naive casting of number’s inner representation to u16by performing x as u16

pub fn to_u8(&self) -> u8

Naive casting of number’s inner representation to u8by performing x as u8

pub fn to_type(&self) -> NumberType

Converts into type of number

Trait Implementations

impl Clone for Number

fn clone(&self) -> Number

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Number

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

Formats the value using the given formatter.

impl<'_enum> From<&'_enum Number> for NumberType

fn from(val: &'_enum Number) -> NumberType

Converts to this type from the input type.

impl From<Number> for NumberType

fn from(val: Number) -> NumberType

Converts to this type from the input type.

impl From<f32> for Number

fn from(original: f32) -> Number

Converts to this type from the input type.

impl From<f64> for Number

fn from(original: f64) -> Number

Converts to this type from the input type.

impl From<i128> for Number

fn from(original: i128) -> Number

Converts to this type from the input type.

impl From<i16> for Number

fn from(original: i16) -> Number

Converts to this type from the input type.

impl From<i32> for Number

fn from(original: i32) -> Number

Converts to this type from the input type.

impl From<i64> for Number

fn from(original: i64) -> Number

Converts to this type from the input type.

impl From<i8> for Number

fn from(original: i8) -> Number

Converts to this type from the input type.

impl From<isize> for Number

fn from(original: isize) -> Number

Converts to this type from the input type.

impl From<u128> for Number

fn from(original: u128) -> Number

Converts to this type from the input type.

impl From<u16> for Number

fn from(original: u16) -> Number

Converts to this type from the input type.

impl From<u32> for Number

fn from(original: u32) -> Number

Converts to this type from the input type.

impl From<u64> for Number

fn from(original: u64) -> Number

Converts to this type from the input type.

impl From<u8> for Number

fn from(original: u8) -> Number

Converts to this type from the input type.

impl From<usize> for Number

fn from(original: usize) -> Number

Converts to this type from the input type.

impl Hash for Number

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl NumberLike for Number

fn into_number(self) -> Number

Consumes this data, converting it into an abstract Number

fn try_from_number(number: Number) -> Result<Self, Number>

Attempts to convert an abstract Number into this data, returning the owned value back if unable to convert

impl PartialEq for Number

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for Number

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

Compares two numbers if possible. If either number is not zero and not normal as defined by Rust’s specification, None is returned.

self sign	other sign	situation
negative	negative	does comparison (less/equal/greater)
negative	positive	less than
negative	zero	less than
positive	negative	greater than
positive	positive	does comparison (less/equal/greater)
positive	zero	greater than
zero	negative	greater than
zero	positive	less than
zero	zero	equal

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Copy for Number

impl Eq for Number