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
113
114
115
116
117
118
119
120
121
122
123
124
// numera::number::integer::nz::integer
//
//!
//
use crate::number::integer::{nz::*, Integer};
use devela::paste;
macro_rules! impl_nonzero_integer {
// $t: base name type
// $b: bitsize
// $inner:
(many: $($t:ident + $b:literal + $inner:ident),+) => {
$( impl_nonzero_integer![$t + $b + $inner]; )+
};
($t:ident + $b:literal + $inner:ident) => { paste! {
/// # Methods for all integers
impl [<$t$b>] {
/// Returns `true` if this integer is even.
#[inline]
#[must_use]
pub const fn is_even(&self) -> bool {
self.0.get() & 1 == 0
}
/// Returns `true` if this integer is odd.
#[inline]
#[must_use]
pub const fn is_odd(&self) -> bool {
!self.is_even()
}
/// Returns `true` if this integer is a multiple of the `other`.
#[inline]
#[must_use]
pub const fn is_multiple_of(&self, other: &Self) -> bool {
self.0.get() % other.0.get() == 0
}
/// Returns `true` if this integer is a divisor of the `other`.
#[inline]
#[must_use]
pub const fn is_divisor_of(&self, other: &Self) -> bool {
other.is_multiple_of(self)
}
// /// Returns `true` if `self` and `other` are relative primes,
// /// which means they have only 1 as their only common divisor.
// ///
// /// # Notation
// /// $a \perp b$.
// #[inline]
// #[must_use]
// pub const fn is_coprime(&self, other: &Self) -> bool {
// self.gcd(other).0 == Self::ONE.0 // FIX
// }
/// Returns the number of digits in base 10.
#[inline]
#[must_use]
pub const fn digits(&self) -> usize {
self.0.ilog10() as usize + 1
}
}
/// # Methods that are open to the result being a different kind of integer.
impl [<$t$b>] {
// TODO: NEED open_neg
//
// /// Calculates the *Greatest Common Divisor* of this integer and `other`.
// #[inline]
// #[must_use]
// pub const fn open_gcd(&self, other: &Self) -> [<PositiveInteger$b>] {
// let pself = [<PositiveInteger$b
// let (mut a, mut b) = (self.0, other.0);
// while b != 0 {
// let temp = b;
// b = a % b;
// a = temp;
// }
// Self(a)
// }
}
impl Integer for [<$t$b>] {
#[inline]
fn integer_is_even(&self) -> bool {
self.is_even()
}
#[inline]
fn integer_is_multiple_of(&self, other: &Self) -> bool {
self.is_multiple_of(other)
}
/// Returns always `None`, since negative numbers can't be prime.
#[inline]
fn integer_is_prime(&self) -> Option<bool> {
None
}
/// Returns always `None`, since the result must be a positive number.
#[inline]
fn integer_gcd(&self, _other: &Self) -> Option<Self> {
None
}
/// Returns always `None`, since the result must be a non-negative number.
#[inline]
fn integer_lcm(&self, _other: &Self) -> Option<Self> {
None
}
#[inline]
fn integer_digits(&self) -> usize {
self.digits()
}
}
}};
}
impl_nonzero_integer![
many: NegativeInteger + 8 + NonZeroU8,
NegativeInteger + 16 + NonZeroU16,
NegativeInteger + 32 + NonZeroU32,
NegativeInteger + 64 + NonZeroU64,
NegativeInteger + 128 + NonZeroU128
];