Module malachite_base::num::arithmetic::round_to_multiple

RoundToMultiple and RoundToMultipleAssign, traits for rounding a number to a multiple of another number.

round_to_multiple

use malachite_base::num::arithmetic::traits::RoundToMultiple;
use malachite_base::rounding_modes::RoundingMode;
use std::cmp::Ordering;

assert_eq!(5u32.round_to_multiple(0, RoundingMode::Down), (0, Ordering::Less));

assert_eq!(10u8.round_to_multiple(4, RoundingMode::Down), (8, Ordering::Less));
assert_eq!(10u16.round_to_multiple(4, RoundingMode::Up), (12, Ordering::Greater));
assert_eq!(10u32.round_to_multiple(5, RoundingMode::Exact), (10, Ordering::Equal));
assert_eq!(10u64.round_to_multiple(3, RoundingMode::Nearest), (9, Ordering::Less));
assert_eq!(20u128.round_to_multiple(3, RoundingMode::Nearest), (21, Ordering::Greater));
assert_eq!(10usize.round_to_multiple(4, RoundingMode::Nearest), (8, Ordering::Less));
assert_eq!(14u8.round_to_multiple(4, RoundingMode::Nearest), (16, Ordering::Greater));

assert_eq!((-5i32).round_to_multiple(0, RoundingMode::Down), (0, Ordering::Greater));

assert_eq!((-10i8).round_to_multiple(4, RoundingMode::Down), (-8, Ordering::Greater));
assert_eq!((-10i16).round_to_multiple(4, RoundingMode::Up), (-12, Ordering::Less));
assert_eq!((-10i32).round_to_multiple(5, RoundingMode::Exact), (-10, Ordering::Equal));
assert_eq!((-10i64).round_to_multiple(3, RoundingMode::Nearest), (-9, Ordering::Greater));
assert_eq!((-20i128).round_to_multiple(3, RoundingMode::Nearest), (-21, Ordering::Less));
assert_eq!((-10isize).round_to_multiple(4, RoundingMode::Nearest), (-8, Ordering::Greater));
assert_eq!((-14i8).round_to_multiple(4, RoundingMode::Nearest), (-16, Ordering::Less));

assert_eq!((-10i16).round_to_multiple(-4, RoundingMode::Down), (-8, Ordering::Greater));
assert_eq!((-10i32).round_to_multiple(-4, RoundingMode::Up), (-12, Ordering::Less));
assert_eq!((-10i64).round_to_multiple(-5, RoundingMode::Exact), (-10, Ordering::Equal));
assert_eq!((-10i128).round_to_multiple(-3, RoundingMode::Nearest), (-9, Ordering::Greater));
assert_eq!((-20isize).round_to_multiple(-3, RoundingMode::Nearest), (-21, Ordering::Less));
assert_eq!((-10i8).round_to_multiple(-4, RoundingMode::Nearest), (-8, Ordering::Greater));
assert_eq!((-14i16).round_to_multiple(-4, RoundingMode::Nearest), (-16, Ordering::Less));

round_to_multiple_assign

use malachite_base::num::arithmetic::traits::RoundToMultipleAssign;
use malachite_base::rounding_modes::RoundingMode;
use std::cmp::Ordering;

let mut x = 5u32;
assert_eq!(x.round_to_multiple_assign(0, RoundingMode::Down), Ordering::Less);
assert_eq!(x, 0);

let mut x = 10u8;
assert_eq!(x.round_to_multiple_assign(4, RoundingMode::Down), Ordering::Less);
assert_eq!(x, 8);

let mut x = 10u16;
assert_eq!(x.round_to_multiple_assign(4, RoundingMode::Up), Ordering::Greater);
assert_eq!(x, 12);

let mut x = 10u32;
assert_eq!(x.round_to_multiple_assign(5, RoundingMode::Exact), Ordering::Equal);
assert_eq!(x, 10);

let mut x = 10u64;
assert_eq!(x.round_to_multiple_assign(3, RoundingMode::Nearest), Ordering::Less);
assert_eq!(x, 9);

let mut x = 20u128;
assert_eq!(x.round_to_multiple_assign(3, RoundingMode::Nearest), Ordering::Greater);
assert_eq!(x, 21);

let mut x = 10usize;
assert_eq!(x.round_to_multiple_assign(4, RoundingMode::Nearest), Ordering::Less);
assert_eq!(x, 8);

let mut x = 14u8;
assert_eq!(x.round_to_multiple_assign(4, RoundingMode::Nearest), Ordering::Greater);
assert_eq!(x, 16);

let mut x = -5i32;
assert_eq!(x.round_to_multiple_assign(0, RoundingMode::Down), Ordering::Greater);
assert_eq!(x, 0);

let mut x = -10i8;
assert_eq!(x.round_to_multiple_assign(4, RoundingMode::Down), Ordering::Greater);
assert_eq!(x, -8);

let mut x = -10i16;
assert_eq!(x.round_to_multiple_assign(4, RoundingMode::Up), Ordering::Less);
assert_eq!(x, -12);

let mut x = -10i32;
assert_eq!(x.round_to_multiple_assign(5, RoundingMode::Exact), Ordering::Equal);
assert_eq!(x, -10);

let mut x = -10i64;
assert_eq!(x.round_to_multiple_assign(3, RoundingMode::Nearest), Ordering::Greater);
assert_eq!(x, -9);

let mut x = -20i128;
assert_eq!(x.round_to_multiple_assign(3, RoundingMode::Nearest), Ordering::Less);
assert_eq!(x, -21);

let mut x = -10isize;
assert_eq!(x.round_to_multiple_assign(4, RoundingMode::Nearest), Ordering::Greater);
assert_eq!(x, -8);

let mut x = -14i8;
assert_eq!(x.round_to_multiple_assign(4, RoundingMode::Nearest), Ordering::Less);
assert_eq!(x, -16);

let mut x = -10i16;
assert_eq!(x.round_to_multiple_assign(-4, RoundingMode::Down), Ordering::Greater);
assert_eq!(x, -8);

let mut x = -10i32;
assert_eq!(x.round_to_multiple_assign(-4, RoundingMode::Up), Ordering::Less);
assert_eq!(x, -12);

let mut x = -10i64;
assert_eq!(x.round_to_multiple_assign(-5, RoundingMode::Exact), Ordering::Equal);
assert_eq!(x, -10);

let mut x = -10i128;
assert_eq!(x.round_to_multiple_assign(-3, RoundingMode::Nearest), Ordering::Greater);
assert_eq!(x, -9);

let mut x = -20isize;
assert_eq!(x.round_to_multiple_assign(-3, RoundingMode::Nearest), Ordering::Less);
assert_eq!(x, -21);

let mut x = -10i8;
assert_eq!(x.round_to_multiple_assign(-4, RoundingMode::Nearest), Ordering::Greater);
assert_eq!(x, -8);

let mut x = -14i16;
assert_eq!(x.round_to_multiple_assign(-4, RoundingMode::Nearest), Ordering::Less);
assert_eq!(x, -16);