Merge pull request #1550 from nbraud/factor/rhofactor

factor::rho: Refactor for readability and fewer allocations

src/uu/factor/src/factor.rs

@@ -32,10 +32,17 @@ struct Factors {
 }
 
 impl Factors {
-    fn new() -> Factors {
+    fn one() -> Factors {
         Factors { f: BTreeMap::new() }
     }
 
+    fn prime(p: u64) -> Factors {
+        debug_assert!(miller_rabin::is_prime(p));
+        let mut f = Factors::one();
+        f.push(p);
+        f
+    }
+
     fn add(&mut self, prime: u64, exp: u8) {
         debug_assert!(exp > 0);
         let n = *self.f.get(&prime).unwrap_or(&0);
@@ -75,7 +82,7 @@ impl fmt::Display for Factors {
 }
 
 fn factor(mut n: u64) -> Factors {
-    let mut factors = Factors::new();
+    let mut factors = Factors::one();
 
     if n < 2 {
         factors.push(n);

src/uu/factor/src/rho.rs

@@ -55,29 +55,21 @@ fn _factor<A: Arithmetic>(num: u64) -> Factors {
         _factor::<A>(n)
     };
 
-    let mut factors = Factors::new();
     if num == 1 {
-        return factors;
+        return Factors::one();
     }
 
     let n = A::new(num);
-    let divisor;
+    let divisor = match miller_rabin::test::<A>(n) {
-    match miller_rabin::test::<A>(n) {
         Prime => {
-            factors.push(num);
+            return Factors::prime(num);
-            return factors;
         }
 
-        Composite(d) => {
+        Composite(d) => d,
-            divisor = d;
+        Pseudoprime => find_divisor::<A>(n),
-        }
-
-        Pseudoprime => {
-            divisor = find_divisor::<A>(n);
-        }
     };
 
-    factors *= _factor(divisor);
+    let mut factors = _factor(divisor);
     factors *= _factor(num / divisor);
     factors
 }

src/uu/factor/src/table.rs

@@ -15,7 +15,7 @@ use crate::Factors;
 include!(concat!(env!("OUT_DIR"), "/prime_table.rs"));
 
 pub(crate) fn factor(mut num: u64) -> (Factors, u64) {
-    let mut factors = Factors::new();
+    let mut factors = Factors::one();
     for &(prime, inv, ceil) in P_INVS_U64 {
         if num == 1 {
             break;