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

//! [`Multiplier`]

use core::num::{NonZeroU128, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize};

use crate::NonZeroPow2;

use super::{NonZeroable, Number};

pub mod public {
	/// See [`Multiplier`](crate::traits::Multiplier).
	pub trait Multiplier {
		/// The type of the multiplied number of this multiplier.
		type Number;
	}
}

pub(crate) mod private {
	pub trait Multiplier: super::public::Multiplier {
		fn get(self) -> Self::Number;

		fn down(self, value: Self::Number) -> Self::Number;
		fn up(self, value: Self::Number) -> Option<Self::Number>;
	}
}

/// A numeric type that may act as a multiplier for another number.
///
/// This helps add safety and optimization:
/// - NonZeroT is a multiplier where T is not, so we don't divide by zero by accident.
/// - [`NonZeroPow2`](crate::NonZeroPow2) takes advanage of its invariant to calculate results faster.
pub trait Multiplier: public::Multiplier + private::Multiplier {}

macro_rules! impl_unsigned_number {
	($($ty:ty : $nz:ty),* $(,)?) => {
		$(
			impl public::Multiplier for $nz {
				type Number = $ty;
			}

			impl private::Multiplier for <$ty as crate::traits::nonzero::public::NonZeroable>::NonZeroType {
				#[inline(always)]
				fn get(self) -> Self::Number {
					self.get()
				}

				#[inline]
				fn down(self, value: Self::Number) -> Self::Number {
					if value % self.get() != 0 {
						value / self.get() * self.get()
					} else {
						value
					}
				}

				#[inline]
				fn up(self, value: Self::Number) -> Option<Self::Number> {
					let r = value % self;
					if r == 0 {
						Some(value)
					} else {
						value.checked_add(self.get() - r)
					}
				}
			}

			impl Multiplier for $nz {}
		)*
	};
}

impl_unsigned_number!(
	u8: NonZeroU8,
	u16: NonZeroU16,
	u32: NonZeroU32,
	u64: NonZeroU64,
	u128: NonZeroU128,
	usize: NonZeroUsize
);

impl<N: NonZeroable> public::Multiplier for NonZeroPow2<N> {
	type Number = N;
}

impl<N: NonZeroable + Number> private::Multiplier for NonZeroPow2<N>
where
	Self: Copy,
{
	#[inline(always)]
	fn get(self) -> Self::Number {
		self.get()
	}

	#[inline(always)]
	fn down(self, value: Self::Number) -> Self::Number {
		value & !(self.get() - N::ONE)
	}

	#[inline(always)]
	fn up(self, value: Self::Number) -> Option<Self::Number> {
		let downed = self.down(value);
		if downed == value {
			return Some(value);
		}
		downed.checked_add(self.get())
	}
}

impl<N: NonZeroable + Number> Multiplier for NonZeroPow2<N> where Self: Copy {}