Enum malachite_base::rounding_modes::RoundingMode

pub enum RoundingMode {
    Down,
    Up,
    Floor,
    Ceiling,
    Nearest,
    Exact,
}

An enum that specifies how a value should be rounded.

A RoundingMode can often be specified when a function conceptually returns a value of one type, but must be rounded to another type. The most common case is a conceptually real-valued function whose result must be rounded to an integer, like div_round.

Examples

Here are some examples of how floating-point values would be rounded to integer values using the different RoundingModes.

x	Floor	Ceiling	Down	Up	Nearest	Exact
3.0	3	3	3	3	3	3
3.2	3	4	3	4	3	panic!()
3.8	3	4	3	4	4	panic!()
3.5	3	4	3	4	4	panic!()
4.5	4	5	4	5	4	panic!()
-3.2	-4	-3	-3	-4	-3	panic!()
-3.8	-4	-3	-3	-4	-4	panic!()
-3.5	-4	-3	-3	-4	-4	panic!()
-4.5	-5	-4	-4	-5	-4	panic!()

Sometimes a RoundingMode is used in an unusual context, such as rounding an integer to a floating-point number, in which case further explanation of its behavior is provided at the usage site.

A RoundingMode takes up 1 byte of space.

Variants

Down

Applies the function $x \mapsto \operatorname{sgn}(x) \lfloor |x| \rfloor$. In other words, the value is rounded towards $0$.

Up

Applies the function $x \mapsto \operatorname{sgn}(x) \lceil |x| \rceil$. In other words, the value is rounded away from $0$.

Floor

Applies the floor function: $x \mapsto \lfloor x \rfloor$. In other words, the value is rounded towards $-\infty$.

Ceiling

Applies the ceiling function: $x \mapsto \lceil x \rceil$. In other words, the value is rounded towards $\infty$.

Nearest

Applies the function $$ x \mapsto \begin{cases} \lfloor x \rfloor & x - \lfloor x \rfloor < \frac{1}{2} \\ \lceil x \rceil & x - \lfloor x \rfloor > \frac{1}{2} \\ \lfloor x \rfloor & x - \lfloor x \rfloor = \frac{1}{2} \ \text{and} \ \lfloor x \rfloor \ \text{is even} \\ \lceil x \rceil & x - \lfloor x \rfloor = \frac{1}{2} \ \text{and} \ \lfloor x \rfloor \ \text{is odd.} \end{cases} $$ In other words, it rounds to the nearest integer, and when there’s a tie, it rounds to the nearest even integer. This is also called bankers’ rounding and is often used as a default.

Exact

Panics if the value is not already rounded.

Trait Implementations

impl Clone for RoundingMode

fn clone(&self) -> RoundingMode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RoundingMode

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

Formats the value using the given formatter.

impl Display for RoundingMode

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

Converts a RoundingMode to a String.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::rounding_modes::RoundingMode;

assert_eq!(RoundingMode::Down.to_string(), "Down");
assert_eq!(RoundingMode::Up.to_string(), "Up");
assert_eq!(RoundingMode::Floor.to_string(), "Floor");
assert_eq!(RoundingMode::Ceiling.to_string(), "Ceiling");
assert_eq!(RoundingMode::Nearest.to_string(), "Nearest");
assert_eq!(RoundingMode::Exact.to_string(), "Exact");

impl FromStr for RoundingMode

fn from_str(src: &str) -> Result<RoundingMode, String>

Converts a string to a RoundingMode.

If the string does not represent a valid RoundingMode, an Err is returned with the unparseable string.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ = src.len().

The worst case occurs when the input string is invalid and must be copied into an Err.

Examples

use malachite_base::rounding_modes::RoundingMode;
use std::str::FromStr;

assert_eq!(RoundingMode::from_str("Down"), Ok(RoundingMode::Down));
assert_eq!(RoundingMode::from_str("Up"), Ok(RoundingMode::Up));
assert_eq!(RoundingMode::from_str("Floor"), Ok(RoundingMode::Floor));
assert_eq!(RoundingMode::from_str("Ceiling"), Ok(RoundingMode::Ceiling));
assert_eq!(RoundingMode::from_str("Nearest"), Ok(RoundingMode::Nearest));
assert_eq!(RoundingMode::from_str("Exact"), Ok(RoundingMode::Exact));
assert_eq!(RoundingMode::from_str("abc"), Err("abc".to_string()));

type Err = String

The associated error which can be returned from parsing.

impl Hash for RoundingMode

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,

Feeds a slice of this type into the given Hasher.

impl Named for RoundingMode

const NAME: &'static str = _

The name of this type, as given by the stringify macro.

See the documentation for impl_named for more details.

impl Neg for RoundingMode

Returns the negative of a RoundingMode.

The negative is defined so that if a RoundingMode $m$ is used to round the result of an odd function $f$, then $f(x, -m) = -f(-x, m)$. Floor and Ceiling are swapped, and the other modes are unchanged.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::rounding_modes::RoundingMode;

assert_eq!(-RoundingMode::Down, RoundingMode::Down);
assert_eq!(-RoundingMode::Up, RoundingMode::Up);
assert_eq!(-RoundingMode::Floor, RoundingMode::Ceiling);
assert_eq!(-RoundingMode::Ceiling, RoundingMode::Floor);
assert_eq!(-RoundingMode::Nearest, RoundingMode::Nearest);
assert_eq!(-RoundingMode::Exact, RoundingMode::Exact);

type Output = RoundingMode

The resulting type after applying the - operator.

fn neg(self) -> RoundingMode

Performs the unary - operation.

impl NegAssign for RoundingMode

fn neg_assign(&mut self)

Replaces a RoundingMode with its negative.

The negative is defined so that if a RoundingMode $m$ is used to round the result of an odd function $f$, then $f(x, -m) = -f(-x, m)$. Floor and Ceiling are swapped, and the other modes are unchanged.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::arithmetic::traits::NegAssign;
use malachite_base::rounding_modes::RoundingMode;

let mut rm = RoundingMode::Down;
rm.neg_assign();
assert_eq!(rm, RoundingMode::Down);

let mut rm = RoundingMode::Floor;
rm.neg_assign();
assert_eq!(rm, RoundingMode::Ceiling);

impl Ord for RoundingMode

fn cmp(&self, other: &RoundingMode) -> Ordering

This method returns an Ordering between self and other.

const fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

const fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

const fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<RoundingMode> for RoundingMode

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd<RoundingMode> for RoundingMode

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

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Copy for RoundingMode

impl Eq for RoundingMode

impl StructuralEq for RoundingMode

impl StructuralPartialEq for RoundingMode