glennib_thelib/
lib.rs

1//! Contains functionality for working with numbers.
2
3/// Returns `true` if the given number is prime, `false` otherwise.
4///
5/// Might block for a while if n is large.
6pub fn is_prime(n: u64) -> bool {
7    if n < 2 {
8        return false;
9    }
10    let mut i = 2;
11    while i * i <= n {
12        if n % i == 0 {
13            return false;
14        }
15        i += 1;
16    }
17    true
18}
19
20/// Returns the next prime number after the given number.
21/// 
22/// # Example
23/// ```
24/// use glennib_thelib::next_prime;
25/// assert_eq!(next_prime(7), 11);
26/// ```
27pub fn next_prime(number: u64) -> u64 {
28    let mut n = number + 1;
29    while !is_prime(n) {
30        n += 1;
31    }
32    n
33}
34
35/// Returns false if the given number is prime, true otherwise.
36pub fn not_prime(n: u64) -> bool {
37    !is_prime(n)
38}
39
40/// Returns the successor of the given number.
41///
42/// # Examples
43///
44/// ```
45/// use glennib_thelib::succ;
46/// let n = 41;
47/// assert_eq!(succ(n), 42);
48/// ```
49pub fn succ(number: u64) -> u64 {
50    number + 1
51}
52
53#[cfg(test)]
54mod test {
55    use super::*;
56
57    #[test]
58    fn is_prime_works() {
59        let expectations = [
60            (1, false),
61            (2, true),
62            (3, true),
63            (4, false),
64            (5, true),
65            (6, false),
66            (7, true),
67            (8, false),
68            (9, false),
69            (10, false),
70            (11, true),
71            (12, false),
72            (13, true),
73        ];
74        for (n, expected) in expectations {
75            assert_eq!(is_prime(n), expected);
76        }
77    }
78
79    #[test]
80    fn next_prime_works() {
81        let expectations = [
82            (1, 2),
83            (2, 3),
84            (3, 5),
85            (4, 5),
86            (5, 7),
87            (6, 7),
88            (7, 11),
89            (8, 11),
90            (9, 11),
91            (10, 11),
92            (11, 13),
93            (12, 13),
94            (13, 17),
95        ];
96        for (n, expected) in expectations {
97            assert_eq!(next_prime(n), expected);
98        }
99    }
100}