Enum Tie 

pub enum Tie {
    Up,
    Down,
    TowardZero,
    AwayFromZero,
    TowardEven,
    TowardOdd,
}

How to handle a value that is exactly half, e.g. 5.round_to(10, ...).

Variants

Up

Round half up (what most people consider correct).

use roundable::{Roundable, Tie};

assert!(10 == 5.round_to(10, Tie::Up));
assert!(0 == (-5).round_to(10, Tie::Up));

// Other values are unaffected:
assert!(0 == 4.round_to(10, Tie::Up));
assert!(10 == 6.round_to(10, Tie::Up));
assert!(0 == (-4).round_to(10, Tie::Up));
assert!(-10 == (-6).round_to(10, Tie::Up));

Down

Round half down.

use roundable::{Roundable, Tie};

assert!(0 == 5.round_to(10, Tie::Down));
assert!(-10 == (-5).round_to(10, Tie::Down));

// Other values are unaffected:
assert!(0 == 4.round_to(10, Tie::Down));
assert!(10 == 6.round_to(10, Tie::Down));
assert!(0 == (-4).round_to(10, Tie::Down));
assert!(-10 == (-6).round_to(10, Tie::Down));

TowardZero

Round half toward zero.

use roundable::{Roundable, Tie};

assert!(0 == 5.round_to(10, Tie::TowardZero));
assert!(0 == (-5).round_to(10, Tie::TowardZero));

// Other values are unaffected:
assert!(0 == 4.round_to(10, Tie::TowardZero));
assert!(10 == 6.round_to(10, Tie::TowardZero));
assert!(0 == (-4).round_to(10, Tie::TowardZero));
assert!(-10 == (-6).round_to(10, Tie::TowardZero));

AwayFromZero

Round half away from zero.

use roundable::{Roundable, Tie};

assert!(10 == 5.round_to(10, Tie::AwayFromZero));
assert!(-10 == (-5).round_to(10, Tie::AwayFromZero));

// Other values are unaffected:
assert!(0 == 4.round_to(10, Tie::AwayFromZero));
assert!(10 == 6.round_to(10, Tie::AwayFromZero));
assert!(0 == (-4).round_to(10, Tie::AwayFromZero));
assert!(-10 == (-6).round_to(10, Tie::AwayFromZero));

TowardEven

Round half toward even.

“Even” has a special meaning here since we only care about round values. If we are rounding to the nearest 10, then 0 is even, 10 is odd, 20 is even, and so on.

If we are rounding to whole numbers, then even and odd have the conventional meaning.

In general, a multiple of factor n is even if (n / factor) % 2 == 0.

Examples

use roundable::{Roundable, Tie};

assert!(20 == 15.round_to(10, Tie::TowardEven));
assert!(0 == 5.round_to(10, Tie::TowardEven));
assert!(0 == (-5).round_to(10, Tie::TowardEven));
assert!(-20 == (-15).round_to(10, Tie::TowardEven));

// Other values are unaffected:
assert!(0 == 4.round_to(10, Tie::TowardEven));
assert!(10 == 6.round_to(10, Tie::TowardEven));
assert!(0 == (-4).round_to(10, Tie::TowardEven));
assert!(-10 == (-6).round_to(10, Tie::TowardEven));

TowardOdd

Round half toward odd.

“Odd” has a special meaning here since we only care about round values. If we are rounding to the nearest 10, then 0 is even, 10 is odd, 20 is even, and so on.

If we are rounding to whole numbers, then even and odd have the conventional meaning.

In general, a multiple of factor n is odd if (n / factor) % 2 != 0.

Examples

use roundable::{Roundable, Tie};

assert!(10 == 15.round_to(10, Tie::TowardOdd));
assert!(10 == 5.round_to(10, Tie::TowardOdd));
assert!(-10 == (-5).round_to(10, Tie::TowardOdd));
assert!(-10 == (-15).round_to(10, Tie::TowardOdd));

// Other values are unaffected:
assert!(0 == 4.round_to(10, Tie::TowardOdd));
assert!(10 == 6.round_to(10, Tie::TowardOdd));
assert!(0 == (-4).round_to(10, Tie::TowardOdd));
assert!(-10 == (-6).round_to(10, Tie::TowardOdd));

Trait Implementations

impl Clone for Tie

fn clone(&self) -> Tie

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Tie

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

Formats the value using the given formatter.

impl PartialEq for Tie

fn eq(&self, other: &Tie) -> 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 Copy for Tie

impl Eq for Tie

impl StructuralPartialEq for Tie