nice_numbers/
sequences.rs

1type SequenceMember = fn(u32) -> u32;
2
3type SequenceNext = fn(Vec<u32>, u32) -> u32;
4
5fn iterate_member(fn_member: SequenceMember, start: u32, length: u32) -> Vec<u32> {
6    let end: u32 = start + length;
7    let mut items: Vec<u32> = Vec::new();
8    (start..end).for_each(|x: u32| {
9        let member: u32 = fn_member(x);
10        items.push(member);
11    });
12    return items;
13}
14
15fn iterate_next(initial: Vec<u32>, fn_next: SequenceNext, start: u32, length: u32) -> Vec<u32> {
16    let end: u32 = start + length;
17    let mut items: Vec<u32> = Vec::from(initial);
18    (start..end).for_each(|x: u32| {
19        let next: u32 = fn_next(items.clone(), x);
20        items.push(next);
21    });
22    return items;
23}
24
25/// <https://oeis.org/A000578>
26pub fn cube_member(nth: u32) -> u32 {
27    return nth * nth * nth;
28}
29
30/// <https://oeis.org/A000578>
31pub fn cube(nth: u32, length: u32) -> Vec<u32> {
32    return iterate_member(cube_member, nth, length);
33}
34
35/// <https://oeis.org/A005843>
36pub fn even_member(nth: u32) -> u32 {
37    return 2 * nth;
38}
39
40/// <https://oeis.org/A005843>
41pub fn even(nth: u32, length: u32) -> Vec<u32> {
42    return iterate_member(even_member, nth, length);
43}
44
45/// <https://oeis.org/A000142>
46pub fn factorial_member(nth: u32) -> u32 {
47    if nth == 0 {
48        return 1;
49    }
50    return nth * factorial_member(nth - 1);
51}
52
53/// <https://oeis.org/A000142>
54pub fn factorial_next(members: Vec<u32>, nth: u32) -> u32 {
55    return members[members.len() - 1] * nth;
56}
57
58/// <https://oeis.org/A000142>
59pub fn factorial(nth: u32, length: u32) -> Vec<u32> {
60    let initial: Vec<u32> = Vec::from([factorial_member(nth)]);
61    return iterate_next(initial, factorial_next, nth + 1, length - 1);
62}
63
64/// <https://oeis.org/A000045>
65pub fn fibonacci_member(nth: u32) -> u32 {
66    if nth == 0 {
67        return 0;
68    }
69    if nth == 1 {
70        return 1;
71    }
72    return fibonacci_member(nth - 1) + fibonacci_member(nth - 2);
73}
74
75/// <https://oeis.org/A000045>
76pub fn fibonacci_next(members: Vec<u32>, _: u32) -> u32 {
77    return members[members.len() - 2] + members[members.len() - 1];
78}
79
80/// <https://oeis.org/A000045>
81pub fn fibonacci(nth: u32, length: u32) -> Vec<u32> {
82    let initial: Vec<u32> = Vec::from([fibonacci_member(nth), fibonacci_member(nth + 1)]);
83    return iterate_next(initial, fibonacci_next, nth + 2, length - 2);
84}
85
86/// <https://oeis.org/A000027>
87pub fn natural_member(nth: u32) -> u32 {
88    return nth;
89}
90
91/// <https://oeis.org/A000027>
92pub fn natural(nth: u32, length: u32) -> Vec<u32> {
93    return iterate_member(natural_member, nth, length);
94}
95
96/// <https://oeis.org/A005408>
97pub fn odd_member(nth: u32) -> u32 {
98    return 2 * nth + 1;
99}
100
101/// <https://oeis.org/A005408>
102pub fn odd(nth: u32, length: u32) -> Vec<u32> {
103    return iterate_member(odd_member, nth, length);
104}
105
106/// <https://oeis.org/A000079>
107pub fn powers2_member(nth: u32) -> u32 {
108    return 2u32.pow(nth);
109}
110
111/// <https://oeis.org/A000079>
112pub fn powers2_next(members: Vec<u32>, _: u32) -> u32 {
113    return members[members.len() - 1] * 2;
114}
115
116/// <https://oeis.org/A000079>
117pub fn powers2(nth: u32, length: u32) -> Vec<u32> {
118    let initial: Vec<u32> = Vec::from([powers2_member(nth)]);
119    return iterate_next(initial, powers2_next, nth + 1, length - 1);
120}
121
122/// <https://oeis.org/A000290>
123pub fn square_member(nth: u32) -> u32 {
124    return nth * nth;
125}
126
127/// <https://oeis.org/A000290>
128pub fn square(nth: u32, length: u32) -> Vec<u32> {
129    return iterate_member(square_member, nth, length);
130}
131
132/// <https://oeis.org/A003154>
133pub fn star_member(nth: u32) -> u32 {
134    if nth == 0 {
135        return 0;
136    }
137    return 6 * nth * (nth - 1) + 1;
138}
139
140/// <https://oeis.org/A003154>
141pub fn star(nth: u32, length: u32) -> Vec<u32> {
142    return iterate_member(star_member, nth, length);
143}
144
145/// <https://oeis.org/A000217>
146pub fn triangular_member(nth: u32) -> u32 {
147    return (nth * (nth + 1)) / 2;
148}
149
150/// <https://oeis.org/A000217>
151pub fn triangular_next(members: Vec<u32>, nth: u32) -> u32 {
152    return members[members.len() - 1] + nth;
153}
154
155/// <https://oeis.org/A000217>
156pub fn triangular(nth: u32, length: u32) -> Vec<u32> {
157    let initial: Vec<u32> = Vec::from([triangular_member(nth)]);
158    return iterate_next(initial, triangular_next, nth + 1, length - 1);
159}
160
161#[cfg(test)]
162mod tests {
163    use super::*;
164
165    #[test]
166    fn test_cube() {
167        assert_eq!(cube(1, 10), [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]);
168    }
169
170    #[test]
171    fn test_even() {
172        assert_eq!(even(0, 10), [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]);
173    }
174
175    #[test]
176    fn test_factorial() {
177        assert_eq!(
178            factorial(0, 10),
179            [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]
180        );
181    }
182
183    #[test]
184    fn test_fibonacci() {
185        assert_eq!(fibonacci(0, 10), [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]);
186    }
187
188    #[test]
189    fn test_natural() {
190        assert_eq!(natural(0, 10), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
191    }
192
193    #[test]
194    fn test_odd() {
195        assert_eq!(odd(0, 10), [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]);
196    }
197
198    #[test]
199    fn test_powers2() {
200        assert_eq!(powers2(0, 10), [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]);
201    }
202
203    #[test]
204    fn test_square() {
205        assert_eq!(square(0, 10), [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]);
206    }
207
208    #[test]
209    fn test_star() {
210        assert_eq!(star(0, 10), [0, 1, 13, 37, 73, 121, 181, 253, 337, 433]);
211    }
212
213    #[test]
214    fn test_triangular() {
215        assert_eq!(triangular(0, 10), [0, 1, 3, 6, 10, 15, 21, 28, 36, 45]);
216    }
217}
nice_numbers/sequences.rs

nice_numbers/
sequences.rs
