add alternate ramp bigint backend

Cargo.toml

@@ -4,15 +4,21 @@ version = "0.1.0"
 authors = ["Tom Milligan <tom@reinfer.io>"]
 edition = "2018"
 
+[features]
+backend-num = ["num-bigint"]
+backend-ramp = ["ramp"]
+default = ["backend-num"]
+
 [dependencies]
 cairo-rs = { version = "0.6.0", features = ["png"] }
 clap = "^2.32.0"
 env_logger = "^0.6.1"
 lazy_static = "^1.3.0"
 log = "^0.4.6"
-num-bigint = "^0.2.2"
+num-bigint = { version = "^0.2.2", optional = true }
 num-traits = "^0.2.6"
 num_cpus = "^1.10.0"
 png = "0.14.0"
+ramp = { version = "0.5.1", optional = true }
 threadpool = "^1.7.1"
 

Makefile

@@ -1,11 +1,15 @@
-.PHONY: dev integrate test
+.PHONY: build-ramp dev integrate test
+
+build-ramp:
+	cargo +nightly build --no-default-features --features backend-ramp
 
 dev:
 	rustup component add rustfmt
+	rustup toolchain install nightly
 
 integrate:
 	./integrate/check
 
 test:
 	cargo fmt -- --check
-	cargo test --locked
+	./test/check

README.md

@@ -8,6 +8,18 @@ Search for integers with high multiplicative persistence values.
 
 This project uses the standard `rustup` and `cargo` toolchain. Originally tested against `rustc 1.33.0`.
 
+By default the library uses `num-bigint` internally. This can be swapped for `ramp` as a dependency by specifying:
+
+```
+multiplicative-persistence = { version = "*", features = ["backend-ramp"], default-features = false }
+```
+
+Or as a binary by building with:
+
+```bash
+cargo +nightly build --no-default-features --features backend-ramp
+```
+
 ## Usage
 
 Build binaries with `cargo build --release --bins`, they will be output in `target/release`:

src/backend/backend_num_bigint.rs

@@ -0,0 +1,48 @@
+extern crate num_bigint;
+extern crate num_traits;
+
+use num_bigint::BigUint;
+use num_traits::Num;
+
+lazy_static! {
+    static ref BIG_UINT_NINE: BigUint = BigUint::from(9 as usize);
+}
+
+/// Multiply digits of an integer together and return the result.
+fn multiply_digits(a: &BigUint) -> BigUint {
+    a.to_str_radix(10)
+        .chars()
+        .map(|c| BigUint::from(c.to_digit(10).expect("Could not convert char to digit.")))
+        .product()
+}
+
+/// Return the multiplicative persistence of a positive integer given as a string.
+pub fn multiplicative_persistence(candidate: &str) -> usize {
+    let mut derived_int: BigUint =
+        Num::from_str_radix(candidate, 10).expect("Could not convert candidate to BigUint");
+
+    let mut counter: usize = 0;
+    while derived_int > *BIG_UINT_NINE {
+        derived_int = multiply_digits(&derived_int);
+        counter += 1;
+    }
+    counter
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    /// Test helper to cut down on boilerplate
+    fn big(n: usize) -> BigUint {
+        BigUint::from(n)
+    }
+
+    #[test]
+    fn test_multiply_digits() {
+        assert_eq!(multiply_digits(&big(0)), big(0));
+        assert_eq!(multiply_digits(&big(3)), big(3));
+        assert_eq!(multiply_digits(&big(24)), big(8));
+        assert_eq!(multiply_digits(&big(12345)), big(120));
+    }
+}

src/backend/backend_ramp.rs

@@ -0,0 +1,48 @@
+extern crate ramp;
+
+use std::ops::Mul;
+
+use ramp::Int;
+
+lazy_static! {
+    static ref RAMP_NINE: Int = Int::from(9);
+}
+
+/// Multiply digits of an integer together and return the result.
+fn multiply_digits(a: &Int) -> Int {
+    a.to_str_radix(10, false)
+        .chars()
+        .map(|c| Int::from(c.to_digit(10).expect("Could not convert char to digit.")))
+        .fold(Int::one(), Int::mul)
+}
+
+/// Return the multiplicative persistence of a positive integer given as a string.
+pub fn multiplicative_persistence(candidate: &str) -> usize {
+    let mut derived_int =
+        Int::from_str_radix(candidate, 10).expect("Could not convert candidate to BigUint");
+
+    let mut counter: usize = 0;
+    while derived_int > *RAMP_NINE {
+        derived_int = multiply_digits(&derived_int);
+        counter += 1;
+    }
+    counter
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    /// Test helper to cut down on boilerplate
+    fn big(n: usize) -> Int {
+        Int::from(n)
+    }
+
+    #[test]
+    fn test_multiply_digits() {
+        assert_eq!(multiply_digits(&big(0)), big(0));
+        assert_eq!(multiply_digits(&big(3)), big(3));
+        assert_eq!(multiply_digits(&big(24)), big(8));
+        assert_eq!(multiply_digits(&big(12345)), big(120));
+    }
+}