cardinalize_numbers 0.1.0

A Rust library for converting numbers into their cardinal English text representation
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

static A_TRILLION: u64 = 1_000_000_000_000;
static A_BILLION: u64 = 1_000_000_000;
static A_MILLION: u64 = 1_000_000;
static A_THOUSAND: u64 = 1_000;
static A_HUNDRED: u64 = 100;

pub fn cardinalize_us_en(number: u64) -> String {
    String::from(cardinalize(number).trim())
}

fn cardinalize(number: u64) -> String {
    println!("Number is: {}", number);
    if number % A_TRILLION != number {
        return cardinalize(number / A_TRILLION)
            + " trillion "
            + cardinalize(number % A_TRILLION).as_str();
    }
    if number % A_BILLION != number {
        return cardinalize(number / A_BILLION)
            + " billion "
            + cardinalize(number % A_BILLION).as_str();
    }
    if number % A_MILLION != number {
        return cardinalize(number / A_MILLION)
            + " million "
            + cardinalize(number % A_MILLION).as_str();
    }
    if number % A_THOUSAND != number {
        return cardinalize(number / A_THOUSAND)
            + " thousand "
            + cardinalize(number % A_THOUSAND).as_str();
    }
    if number % A_HUNDRED != number {
        return cardinalize(number / A_HUNDRED)
            + " hundred "
            + cardinalize(number % A_HUNDRED).as_str();
    }
    if number % 90 != number {
        return String::from("ninety ") + cardinalize(number % 90).as_str();
    }
    if number % 80 != number {
        return String::from("eighty ") + cardinalize(number % 80).as_str();
    }
    if number % 70 != number {
        return String::from("seventy ") + cardinalize(number % 70).as_str();
    }
    if number % 60 != number {
        return String::from("sixty ") + cardinalize(number % 60).as_str();
    }
    if number % 50 != number {
        return String::from("fifty ") + cardinalize(number % 50).as_str();
    }
    if number % 40 != number {
        return String::from("forty ") + cardinalize(number % 40).as_str();
    }
    if number % 30 != number {
        return String::from("thirty ") + cardinalize(number % 30).as_str();
    }
    if number % 20 != number {
        return String::from("twenty ") + cardinalize(number % 20).as_str();
    }
    if number == 19 {
        return String::from("nineteen");
    }
    if number == 18 {
        return String::from("eighteen");
    }
    if number == 17 {
        return String::from("seventeen");
    }
    if number == 16 {
        return String::from("sixteen");
    }
    if number == 15 {
        return String::from("fifteen");
    }
    if number == 14 {
        return String::from("fourteen");
    }
    if number == 13 {
        return String::from("thirteen");
    }
    if number == 12 {
        return String::from("twelve");
    }
    if number == 11 {
        return String::from("eleven");
    }
    if number == 10 {
        return String::from("ten");
    }
    if number == 9 {
        return String::from("nine");
    }
    if number == 8 {
        return String::from("eight");
    }
    if number == 7 {
        return String::from("seven");
    }
    if number == 6 {
        return String::from("six");
    }
    if number == 5 {
        return String::from("five");
    }
    if number == 4 {
        return String::from("four");
    }
    if number == 3 {
        return String::from("three");
    }
    if number == 2 {
        return String::from("two");
    }
    if number == 1 {
        return String::from("one");
    }
    return String::from("");
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_works() {
        assert_eq!(cardinalize_us_en(1), String::from("one"));
        assert_eq!(cardinalize_us_en(100), String::from("one hundred"));
        assert_eq!(cardinalize_us_en(200), String::from("two hundred"));
        assert_eq!(cardinalize_us_en(202), String::from("two hundred two"));
        assert_eq!(
            cardinalize_us_en(575),
            String::from("five hundred seventy five")
        );
        assert_eq!(
            cardinalize_us_en(8_575),
            String::from("eight thousand five hundred seventy five")
        );
        assert_eq!(
            cardinalize_us_en(1_398_575),
            String::from(
                "one million three hundred ninety eight thousand five hundred seventy five"
            )
        );
        assert_eq!(
            cardinalize_us_en(1_384_949_984),
            String::from(
                "one billion three hundred eighty four million nine hundred forty nine thousand nine hundred eighty four"
            )
        );
        assert_eq!(
            cardinalize_us_en(999_999_999_999_001),
            "nine hundred ninety nine trillion nine hundred ninety nine billion nine hundred ninety nine million nine hundred ninety nine thousand one"
        )
    }
}