rusty-numbers/src/lib.rs
Timothy Warren 57526e5fed
Some checks failed
timw4mail/rusty-numbers/pipeline/head There was a failure building this commit
Some minor stuff for bigints
2020-02-24 16:30:59 -05:00

251 lines
5.8 KiB
Rust

//! # Rusty Numbers
//!
//! Playin' with Numerics in Rust
#![forbid(unsafe_code)]
#[cfg_attr(tarpaulin, skip)]
pub mod bigint;
pub mod num;
pub mod rational;
/// Calculate a number in the fibonacci sequence,
/// using recursion and a lookup table
///
/// Can calculate up to 186 using native unsigned 128 bit integers.
///
/// Example:
/// ```rust
/// use rusty_numbers::mem_fibonacci;
///
/// let valid = mem_fibonacci(45); // Some(1134903170)
/// # assert_eq!(1134903170, mem_fibonacci(45).unwrap());
/// # assert!(valid.is_some());
///
/// let invalid = mem_fibonacci(187); // None
/// # assert!(invalid.is_none());
/// ```
#[inline]
pub fn mem_fibonacci(n: usize) -> Option<u128> {
let mut table = [0u128; 187];
table[0] = 0;
table[1] = 1;
table[2] = 1;
/// Actual calculating function for `fibonacci`
fn f(n: usize, table: &mut [u128]) -> Option<u128> {
if n < 2 {
// The first values are predefined.
return Some(table[n]);
}
if n > 186 {
return None;
}
match table[n] {
// The lookup array starts out zeroed, so a zero
// is a not yet calculated value
0 => {
let a = f(n - 1, table)?;
let b = f(n - 2, table)?;
table[n] = a + b;
Some(table[n])
}
x => Some(x),
}
}
f(n, &mut table)
}
/// Calculate a number in the fibonacci sequence,
/// using naive recursion
///
/// REALLY SLOW
///
/// Can calculate up to 186 using native unsigned 128 bit integers.
#[inline]
pub fn rec_fibonacci(n: usize) -> Option<u128> {
match n {
0 => Some(0),
1 => Some(1),
n => {
let a = rec_fibonacci(n - 1)?;
let b = rec_fibonacci(n - 2)?;
a.checked_add(b)
}
}
}
/// Calculate a number in the fibonacci sequence,
///
/// Can calculate up to 186 using native unsigned 128 bit integers.
///
/// Example:
/// ```rust
/// use rusty_numbers::fibonacci;
///
/// let valid = fibonacci(45); // Some(1134903170)
/// # assert_eq!(1134903170, fibonacci(45).unwrap());
/// # assert!(valid.is_some());
///
/// let invalid = fibonacci(187); // None
/// # assert!(invalid.is_none());
/// ```
#[inline]
pub fn fibonacci(n: usize) -> Option<u128> {
let mut a: u128 = 0;
let mut b: u128 = 1;
match n {
0 => Some(a),
1 => Some(b),
_ => {
for _ in 0..n - 1 {
let c: u128 = a.checked_add(b)?;
a = b;
b = c;
}
Some(b)
}
}
}
/// Calculate the value of a factorial iteratively
///
/// Can calculate up to 34! using native unsigned 128 bit integers.
///
/// Example:
/// ```rust
/// use rusty_numbers::factorial;
///
/// let valid = factorial(3); // Some(6)
/// # assert_eq!(6, valid.unwrap());
///
/// let invalid = factorial(35); // None
/// # assert!(invalid.is_none());
/// ```
#[inline]
pub fn it_factorial(n: usize) -> Option<u128> {
let mut total: u128 = 1;
match n {
0 | 1 => Some(1u128),
_ => {
for x in 1..=n {
total = total.checked_mul(x as u128)?;
}
Some(total)
}
}
}
/// Calculate the value of a factorial recrursively
///
/// Can calculate up to 34! using native unsigned 128 bit integers.
///
/// Example:
/// ```rust
/// use rusty_numbers::factorial;
///
/// let valid = factorial(3); // Some(6)
/// # assert_eq!(6, valid.unwrap());
///
/// let invalid = factorial(35); // None
/// # assert!(invalid.is_none());
/// ```
#[inline]
pub fn factorial(n: usize) -> Option<u128> {
match n {
0 => Some(1u128),
1 => Some(1u128),
_ => {
let prev = factorial(n - 1)?;
(n as u128).checked_mul(prev)
}
}
}
#[cfg(test)]
#[cfg_attr(tarpaulin, skip)]
mod tests {
use super::*;
#[test]
fn test_factorial() {
for pair in [[1usize, 0], [1, 1], [2, 2], [6, 3]].iter() {
assert_eq!(
Some(pair[0] as u128),
factorial(pair[1]),
"{}! should be {}",
pair[1],
pair[0]
);
assert_eq!(
Some(pair[0] as u128),
it_factorial(pair[1]),
"{}! should be {}",
pair[1],
pair[0]
);
}
// Verify each implementation returns the same results
let res = factorial(34);
let res2 = it_factorial(34);
assert!(res.is_some());
assert!(res2.is_some());
assert_eq!(res, res2);
// Bounds checks
assert!(factorial(35).is_none());
assert!(it_factorial(35).is_none());
}
#[test]
fn test_fibonacci() {
// Sanity checking
for pair in [[0usize, 0], [1, 1], [1, 2], [2, 3]].iter() {
assert_eq!(
Some(pair[0] as u128),
fibonacci(pair[1]),
"fibonacci({}) should be {}",
pair[1],
pair[0]
);
assert_eq!(
Some(pair[0] as u128),
mem_fibonacci(pair[1]),
"fibonacci({}) should be {}",
pair[1],
pair[0]
);
assert_eq!(
Some(pair[0] as u128),
rec_fibonacci(pair[1]),
"fibonacci({}) should be {}",
pair[1],
pair[0]
);
}
// Verify each implementation returns the same results
let res = fibonacci(186);
let res2 = mem_fibonacci(186);
assert!(res.is_some());
assert!(res2.is_some());
assert_eq!(res, res2);
// Bounds checks
assert!(fibonacci(187).is_none());
assert!(mem_fibonacci(187).is_none());
}
}