round_mult 0.1.4

A tiny library to round a number up or down to a multiplier.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

#![doc = include_str!("../README.md")]
#![no_std]
#![deny(clippy::missing_inline_in_public_items, missing_docs)]
#![cfg_attr(nightly, feature(portable_simd))]

mod nzp;
#[cfg(nightly)]
pub use nzp::LanesMult;
pub use nzp::NonZeroPow2;

pub mod traits;
use traits::Multiplier;

/// Rounds the number down.
#[inline(always)]
pub fn down<M: Multiplier>(
	value: M::Number, multiplier: M
) -> M::Number {
	multiplier.down(value)
}

/// Rounds the number up.
///
/// Returns [`None`] if the result overflows.
#[inline(always)]
pub fn up<M: Multiplier>(
	value: M::Number, multiplier: M
) -> Option<M::Number> {
	multiplier.up(value)
}

#[cfg(test)]
mod test {
	use core::num::NonZeroU8;

	use quickcheck::TestResult;
	use quickcheck_macros::quickcheck;

	use super::*;

	#[quickcheck]
	fn mult2_down_round_mult_is_identity(value: NonZeroPow2<u8>) -> bool {
		down(value.get(), value) == value.get()
	}

	#[quickcheck]
	fn mult2_up_round_mult_is_identity(value: NonZeroPow2<u8>) -> bool {
		up(value.get(), value) == Some(value.get())
	}

	#[quickcheck]
	fn mult_down_round_mult_is_identity(value: NonZeroU8) -> bool {
		down(value.get(), value) == value.get()
	}

	#[quickcheck]
	fn mult_up_round_mult_is_identity(value: NonZeroU8) -> bool {
		up(value.get(), value) == Some(value.get())
	}

	#[quickcheck]
	fn mult_up_overflow_is_none(value: u8, mult: NonZeroU8) -> TestResult {
		if
			value % mult.get() != 0 &&
			u8::MAX - ((value / mult) * mult.get()) < mult.get()
		{
			TestResult::from_bool(up(value, mult).is_none())
		} else {
			TestResult::discard()
		}
	}

	#[quickcheck]
	fn mult2_up_overflow_is_none(
		value: u8, mult: NonZeroPow2<u8>
	) -> TestResult {
		if
			value % mult.get() != 0 &&
			u8::MAX - ((value / mult.get()) * mult.get()) < mult.get()
		{
			TestResult::from_bool(up(value, mult).is_none())
		} else {
			TestResult::discard()
		}
	}

	#[quickcheck]
	fn mult2_down_is_correct(value: u8, mult: NonZeroPow2<u8>) -> bool {
		down(value, mult) == (value / mult.get()) * mult.get()
	}

	#[quickcheck]
	fn mult_down_is_correct(value: u8, mult: NonZeroU8) -> bool {
		down(value, mult) == (value / mult.get()) * mult.get()
	}

	#[test]
	fn up_12_4_identity() {
		assert_eq!(
			up(12_usize, NonZeroPow2::new(4).unwrap()).unwrap(),
			12
		);
	}

	#[test]
	fn down_12_4() {
		assert_eq!(
			down(12_usize, NonZeroPow2::new(4).unwrap()),
			12
		);
	}
}