Implemented a prime factorization function using Pollard Rho and a test program.

Author: netromdk

CMakeLists.txt

@@ -27,7 +27,7 @@ OPTION( BUILD_TESTS "Set to ON to build test programs" OFF )
 FIND_PACKAGE( GMP REQUIRED )
 INCLUDE_DIRECTORIES( ${GMP_INCLUDE_DIR} )
 
-ADD_DEFINITIONS( "-Wall" )
+ADD_DEFINITIONS( "-Wall -Wno-unused-function" )
 ADD_SUBDIRECTORY( src )
 
 # Build test programs.

src/PollardRho.cpp

@@ -7,6 +7,24 @@
 namespace Math {
   namespace Fac {
     namespace {
+      void pollardRhoFactor0(mpz_t n, vector<mpz_t*> &facs) {
+        if (isPropPrime(n)) {
+          mpz_t *tmp = new mpz_t[1];
+          mpz_init(*tmp);
+          mpz_set(*tmp, n);
+          facs.push_back(tmp);
+          return;
+        }
+
+        mpz_t *g = new mpz_t[1];
+        mpz_init(*g);
+        pollardRho(n, *g);
+        facs.push_back(g);
+
+        mpz_divexact(n, n, *g);
+        pollardRhoFactor0(n, facs);
+      }
+      
       void func(mpz_t r, const mpz_t x, const mpz_t a, const mpz_t n) {
         mpz_mul(r, x, x);
         mpz_add(r, r, a);
@@ -18,6 +36,14 @@ namespace Math {
       }
     }
 
+    void pollardRhoFactor(const mpz_t n, vector<mpz_t*> &facs) {
+      mpz_t tmp;
+      mpz_init(tmp);
+      mpz_set(tmp, n);
+      pollardRhoFactor0(tmp, facs);
+      mpz_clear(tmp);
+    }
+
     void pollardRho(const mpz_t n, mpz_t f) {
       // Return n as the factor if it's a probable-prime.      
       if (isPropPrime(n)) {

src/PollardRho.h

@@ -2,14 +2,23 @@
 #define MATH_POLLARD_RHO_H
 
 #include <gmp.h>
+#include <vector>
+using namespace std;
 
 namespace Math {
   namespace Fac {
     namespace {
+      void pollardRhoFactor0(mpz_t n, vector<mpz_t*> &facs);    
       void func(mpz_t r, const mpz_t x, const mpz_t a, const mpz_t n);
       int funcI(int x, int a, int n);
     }
 
+    /**
+     * Finds the prime factorization of n and puts them in the vector
+     * facs.
+     */
+    void pollardRhoFactor(const mpz_t n, vector<mpz_t*> &facs);        
+
     /**
      * Finds a nontrivial factor of composite number n of arbitrary
      * size and writes the result to f.

test/CMakeLists.txt

@@ -12,3 +12,6 @@ TARGET_LINK_LIBRARIES( PollardRhoI ${CORELIBS} )
 ADD_EXECUTABLE( PollardRho PollardRho.cpp ) 
 TARGET_LINK_LIBRARIES( PollardRho ${CORELIBS} )
 
+ADD_EXECUTABLE( PollardRhoFactor PollardRhoFactor.cpp ) 
+TARGET_LINK_LIBRARIES( PollardRhoFactor ${CORELIBS} )
+

test/PollardRhoFactor.cpp

@@ -0,0 +1,53 @@
+#include <gmp.h>
+#include <vector>
+#include <sstream>
+#include <iostream>
+using namespace std;
+
+#include "Common.h"
+#include "PollardRho.h"
+using namespace Math;
+using namespace Math::Fac;
+
+#include "TestCommon.h"
+
+void usage(char **argv) {
+  cout << "Usage: " << argv[0] << " <num>" << endl
+       << "Find a nontrivial prime factor of <num>." << endl;
+}
+
+int main(int argc, char **argv) {
+  if (argc != 2) {
+    usage(argv);
+    return -1;
+  }
+
+  mpz_t num;
+  mpz_init(num);
+  if (mpz_set_str(num, argv[1], 10) == -1) {
+    mpz_clear(num);
+    usage(argv);
+    return -1;
+  }
+
+  vector<mpz_t*> facs;  
+  pollardRhoFactor(num, facs);
+
+  dump(num, "Prime factorization of", false);
+  cout << " is [";
+  vector<mpz_t*>::iterator it; 
+  for (it = facs.begin(); it != facs.end(); it++) {
+    dump(**it, "", false);
+
+    if (it + 1 != facs.end()) {
+      cout << ", ";
+    }
+    
+    mpz_clear(**it);
+    delete[] *it;
+  }
+  cout << "]" << endl;
+
+  mpz_clear(num);
+  return 0;
+}