algs 0.1.2

Solutions for various algorithms, made as generic as possible
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

use std::{error::Error, fmt};

use funty::Integral;

#[derive(Debug, PartialEq)]
pub struct IntReverseError {
    details: String,
}

impl IntReverseError {
    fn new(msg: &str) -> IntReverseError {
        IntReverseError {
            details: msg.to_string(),
        }
    }
}

impl fmt::Display for IntReverseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.details)
    }
}

impl Error for IntReverseError {
    fn description(&self) -> &str {
        &self.details
    }
}

/// Reverse any integer type, if that would result
pub fn reverse<T>(x: T) -> Result<T, IntReverseError>
where
    T: Integral,
{
    let _0: T = T::ZERO;
    let _2 = T::ONE + T::ONE;
    let _8 = _2 * _2 * _2;
    let _10 = _2 + _8;

    let mut res: T = T::ZERO;
    let mut rem = x;

    while rem != T::ZERO {
        let tmp = res.checked_mul(_10).ok_or(IntReverseError::new("Oh no"))?;
        res = tmp
            .checked_add(rem.rem(_10))
            .ok_or(IntReverseError::new("Oh no"))?;

        Some(rem = rem / _10);
    }
    Ok(res)
}

#[test]
fn reverse_works() {
    assert_eq!(reverse(54021), Ok(12045));
}

#[test]
fn reverse_neg_works() {
    assert_eq!(reverse(-54021), Ok(-12045));
}

#[test]
fn zero_from_out_of_bounds_add() {
    assert_eq!(reverse(1563847412), Err(IntReverseError::new("Oh no")));
}

#[test]
fn zero_from_out_of_bounds_mult() {
    assert_eq!(reverse(1534236469), Err(IntReverseError::new("Oh no")));
}