Module malachite_float::conversion::primitive_int_from_float

Expand description

Functions and implementations of traits for converting a Float to a primitive integer.

The traits are TryFrom, ConvertibleFrom, and RoundingFrom.

§rounding_from

use malachite_base::num::conversion::traits::RoundingFrom;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_float::Float;
use std::cmp::Ordering::*;

assert_eq!(u8::rounding_from(Float::from(1.5), Floor), (1, Less));
assert_eq!(u8::rounding_from(Float::from(1.5), Ceiling), (2, Greater));
assert_eq!(u8::rounding_from(Float::from(1.5), Nearest), (2, Greater));

assert_eq!(u8::rounding_from(Float::from(256.0), Down), (255, Less));
assert_eq!(u8::rounding_from(Float::from(256.0), Floor), (255, Less));
assert_eq!(u8::rounding_from(Float::from(256.0), Nearest), (255, Less));

assert_eq!(u8::rounding_from(Float::from(-123.0), Down), (0, Greater));
assert_eq!(
    u8::rounding_from(Float::from(-123.0), Ceiling),
    (0, Greater)
);
assert_eq!(
    u8::rounding_from(Float::from(-123.0), Nearest),
    (0, Greater)
);

assert_eq!(i8::rounding_from(Float::from(1.5), Floor), (1, Less));
assert_eq!(i8::rounding_from(Float::from(1.5), Ceiling), (2, Greater));
assert_eq!(i8::rounding_from(Float::from(1.5), Nearest), (2, Greater));

assert_eq!(i8::rounding_from(Float::from(-1.5), Floor), (-2, Less));
assert_eq!(i8::rounding_from(Float::from(-1.5), Ceiling), (-1, Greater));
assert_eq!(i8::rounding_from(Float::from(-1.5), Nearest), (-2, Less));

assert_eq!(i8::rounding_from(Float::from(128.0), Down), (127, Less));
assert_eq!(i8::rounding_from(Float::from(128.0), Floor), (127, Less));
assert_eq!(i8::rounding_from(Float::from(128.0), Nearest), (127, Less));

assert_eq!(
    i8::rounding_from(Float::from(-129.0), Down),
    (-128, Greater)
);
assert_eq!(
    i8::rounding_from(Float::from(-129.0), Ceiling),
    (-128, Greater)
);
assert_eq!(
    i8::rounding_from(Float::from(-129.0), Nearest),
    (-128, Greater)
);

assert_eq!(u8::rounding_from(&Float::from(1.5), Floor), (1, Less));
assert_eq!(u8::rounding_from(&Float::from(1.5), Ceiling), (2, Greater));
assert_eq!(u8::rounding_from(&Float::from(1.5), Nearest), (2, Greater));

assert_eq!(u8::rounding_from(&Float::from(256.0), Down), (255, Less));
assert_eq!(u8::rounding_from(&Float::from(256.0), Floor), (255, Less));
assert_eq!(u8::rounding_from(&Float::from(256.0), Nearest), (255, Less));

assert_eq!(u8::rounding_from(&Float::from(-123.0), Down), (0, Greater));
assert_eq!(
    u8::rounding_from(&Float::from(-123.0), Ceiling),
    (0, Greater)
);
assert_eq!(
    u8::rounding_from(&Float::from(-123.0), Nearest),
    (0, Greater)
);

assert_eq!(i8::rounding_from(&Float::from(1.5), Floor), (1, Less));
assert_eq!(i8::rounding_from(&Float::from(1.5), Ceiling), (2, Greater));
assert_eq!(i8::rounding_from(&Float::from(1.5), Nearest), (2, Greater));

assert_eq!(i8::rounding_from(&Float::from(-1.5), Floor), (-2, Less));
assert_eq!(
    i8::rounding_from(&Float::from(-1.5), Ceiling),
    (-1, Greater)
);
assert_eq!(i8::rounding_from(&Float::from(-1.5), Nearest), (-2, Less));

assert_eq!(i8::rounding_from(&Float::from(128.0), Down), (127, Less));
assert_eq!(i8::rounding_from(&Float::from(128.0), Floor), (127, Less));
assert_eq!(i8::rounding_from(&Float::from(128.0), Nearest), (127, Less));

assert_eq!(
    i8::rounding_from(&Float::from(-129.0), Down),
    (-128, Greater)
);
assert_eq!(
    i8::rounding_from(&Float::from(-129.0), Ceiling),
    (-128, Greater)
);
assert_eq!(
    i8::rounding_from(&Float::from(-129.0), Nearest),
    (-128, Greater)
);

§try_from

use malachite_base::num::basic::traits::{Infinity, NaN, Zero};
use malachite_base::num::conversion::from::{SignedFromFloatError, UnsignedFromFloatError};
use malachite_float::Float;

assert_eq!(u8::try_from(Float::ZERO).unwrap(), 0);
assert_eq!(u8::try_from(Float::from(123.0)).unwrap(), 123);

assert_eq!(
    u8::try_from(Float::from(-123.0)),
    Err(UnsignedFromFloatError::FloatNegative)
);
assert_eq!(
    u8::try_from(Float::from(256.0)),
    Err(UnsignedFromFloatError::FloatNonIntegerOrOutOfRange)
);
assert_eq!(
    u8::try_from(Float::from(1.5)),
    Err(UnsignedFromFloatError::FloatNonIntegerOrOutOfRange)
);
assert_eq!(
    u8::try_from(Float::INFINITY),
    Err(UnsignedFromFloatError::FloatInfiniteOrNan)
);
assert_eq!(
    u8::try_from(Float::NAN),
    Err(UnsignedFromFloatError::FloatInfiniteOrNan)
);

assert_eq!(i8::try_from(Float::ZERO).unwrap(), 0);
assert_eq!(i8::try_from(Float::from(123.0)).unwrap(), 123);
assert_eq!(i8::try_from(Float::from(-123.0)).unwrap(), -123);

assert_eq!(
    i8::try_from(Float::from(128.0)),
    Err(SignedFromFloatError::FloatNonIntegerOrOutOfRange)
);
assert_eq!(
    i8::try_from(Float::from(-129.0)),
    Err(SignedFromFloatError::FloatNonIntegerOrOutOfRange)
);
assert_eq!(
    i8::try_from(Float::from(1.5)),
    Err(SignedFromFloatError::FloatNonIntegerOrOutOfRange)
);
assert_eq!(
    i8::try_from(Float::INFINITY),
    Err(SignedFromFloatError::FloatInfiniteOrNan)
);
assert_eq!(
    i8::try_from(Float::NAN),
    Err(SignedFromFloatError::FloatInfiniteOrNan)
);

assert_eq!(u8::try_from(&Float::ZERO).unwrap(), 0);
assert_eq!(u8::try_from(&Float::from(123.0)).unwrap(), 123);

assert_eq!(
    u8::try_from(&Float::from(-123.0)),
    Err(UnsignedFromFloatError::FloatNegative)
);
assert_eq!(
    u8::try_from(&Float::from(256.0)),
    Err(UnsignedFromFloatError::FloatNonIntegerOrOutOfRange)
);
assert_eq!(
    u8::try_from(&Float::from(1.5)),
    Err(UnsignedFromFloatError::FloatNonIntegerOrOutOfRange)
);
assert_eq!(
    u8::try_from(&Float::INFINITY),
    Err(UnsignedFromFloatError::FloatInfiniteOrNan)
);
assert_eq!(
    u8::try_from(&Float::NAN),
    Err(UnsignedFromFloatError::FloatInfiniteOrNan)
);

assert_eq!(i8::try_from(&Float::ZERO).unwrap(), 0);
assert_eq!(i8::try_from(&Float::from(123.0)).unwrap(), 123);
assert_eq!(i8::try_from(&Float::from(-123.0)).unwrap(), -123);

assert_eq!(
    i8::try_from(&Float::from(128.0)),
    Err(SignedFromFloatError::FloatNonIntegerOrOutOfRange)
);
assert_eq!(
    i8::try_from(&Float::from(-129.0)),
    Err(SignedFromFloatError::FloatNonIntegerOrOutOfRange)
);
assert_eq!(
    i8::try_from(&Float::from(1.5)),
    Err(SignedFromFloatError::FloatNonIntegerOrOutOfRange)
);
assert_eq!(
    i8::try_from(&Float::INFINITY),
    Err(SignedFromFloatError::FloatInfiniteOrNan)
);
assert_eq!(
    i8::try_from(&Float::NAN),
    Err(SignedFromFloatError::FloatInfiniteOrNan)
);

§convertible_from

use malachite_base::num::basic::traits::{Infinity, NaN, Zero};
use malachite_base::num::conversion::traits::ConvertibleFrom;
use malachite_float::Float;

assert_eq!(u8::convertible_from(&Float::ZERO), true);
assert_eq!(u8::convertible_from(&Float::from(123.0)), true);

assert_eq!(u8::convertible_from(&Float::from(256.0)), false);
assert_eq!(u8::convertible_from(&Float::from(-123.0)), false);
assert_eq!(u8::convertible_from(&Float::from(1.5)), false);
assert_eq!(u8::convertible_from(&Float::INFINITY), false);
assert_eq!(u8::convertible_from(&Float::NAN), false);

assert_eq!(i8::convertible_from(&Float::ZERO), true);
assert_eq!(i8::convertible_from(&Float::from(123.0)), true);
assert_eq!(i8::convertible_from(&Float::from(-123.0)), true);

assert_eq!(i8::convertible_from(&Float::from(128.0)), false);
assert_eq!(i8::convertible_from(&Float::from(-129.0)), false);
assert_eq!(i8::convertible_from(&Float::from(1.5)), false);
assert_eq!(i8::convertible_from(&Float::INFINITY), false);
assert_eq!(i8::convertible_from(&Float::NAN), false);

Module malachite_float::conversion::primitive_int_from_floatCopy item path

§rounding_from

§try_from

§convertible_from

Module malachite_float::conversion::primitive_int_from_float