Implement factorization (PollarsPho) (#2)

Author: RaphaelRevivor

BUILD

@@ -0,0 +1,6 @@
+module(
+  name = "cpp-analytics-devops",
+  version = "1.0.0",
+)
+
+bazel_dep(name = "googletest", version = "1.17.0")

src/BUILD

@@ -0,0 +1,20 @@
+cc_library(
+  name = "factorLib",
+  srcs = [
+    "factor.cpp"
+  ],
+  hdrs = [
+    "factor.h"
+  ],
+)
+
+cc_binary(
+  name = "mainProg",
+  srcs = [
+    "main.cpp",
+    "main.h",
+  ],
+  deps = [
+    ":factorLib",
+  ], 
+)

src/factor.cpp

@@ -0,0 +1,91 @@
+#include "factor.h"
+
+using namespace std;
+
+// === member functions for PollardsPho ===
+
+/// @brief constructor
+/// @param n the value for fatorization
+PollardsPho::PollardsPho(int64_t n) : n(n)
+{
+  srand(time(0));
+}
+
+/// @brief the main function to do the calculation
+/// @return result
+int64_t PollardsPho::calculate()
+{
+  int64_t d = 1;
+  int64_t cnt = 0;
+  int64_t x = selectX0();
+  int64_t y = x;
+
+  while(d == 1 || d == n)
+  {
+    d = basicIteration(x, y);
+
+    cout << cnt << ":" << endl;
+    cout << "x, y, d:" << x << "," << y << "," << d << endl;
+
+    if (d == n)
+    {
+      failure++;
+    }
+    cnt++;
+  }
+
+  return d;
+}
+
+/// @brief basic iteration of the algorithm
+/// @param x x
+/// @param y y
+/// @return d
+int64_t PollardsPho::basicIteration(int64_t &x, int64_t &y)
+{
+  selectC(c);
+  x = polyFuncMod(x, c);
+  y = polyFuncMod(polyFuncMod(y, c), c);
+  int64_t d = calculateD(x, y);
+
+  return d;
+}
+
+int64_t PollardsPho::selectX0()
+{
+  return (rand() % (n - 2)) + 2;
+}
+
+/// @brief function to calculate f(x) = x^2 + c
+/// @param x x
+/// @param c c
+/// @return f(x)
+int64_t PollardsPho::polyFuncMod(int64_t x, int64_t c)
+{
+  __int128_t output = (x * x + c) % n;
+  return output;
+}
+
+/// @brief funtion to calculate D = gcd(abs(x-y), n)
+int64_t PollardsPho::calculateD(int64_t x, int64_t y)
+{
+  return gcd(abs(x-y), n);
+}
+
+/// @brief function to select c
+/// @return c
+void PollardsPho::selectC(int64_t& input)
+{
+  if (failure < 100)
+    input = 1;
+  else if (failure < 200)
+    input = 2;
+  else if (failure < 300)
+    input = 3;
+  // choose from [4, n)
+  else
+    input = (rand() % (n - 4)) + 4;
+}
+
+
+// === member functions for Factorization ===

src/factor.h

@@ -0,0 +1,41 @@
+#ifndef FACTOR_H
+#define FACTOR_H
+
+#include <vector>
+#include <iostream>
+#include <cstdint>
+#include <ctime>
+#include <cmath>
+#include <cstdlib>
+#include <numeric>
+
+class PollardsPho
+{
+public:
+  PollardsPho(int64_t n);
+  ~PollardsPho() = default;
+  int64_t calculate();
+
+private:
+  int64_t n;
+  int64_t c;
+  int64_t failure = 0;
+  int64_t polyFuncMod(int64_t x, int64_t c);
+  int64_t calculateD(int64_t x, int64_t y);
+  void selectC(int64_t& input);
+  int64_t selectX0();
+  int64_t basicIteration(int64_t &x, int64_t &y);
+};
+
+// class Factorization
+// {
+// public:
+//   Factorization(int64_t n) : n(n)
+//   {
+//   }
+//   ~Factorization() = default;
+// private:
+//   int64_t n;
+// };
+
+#endif

src/main.cpp

@@ -0,0 +1,12 @@
+#include "main.h"
+
+using namespace std;
+
+int main()
+{
+  int64_t n = 10967535067;
+  auto pollardsPho = PollardsPho(n);
+  auto result = pollardsPho.calculate();
+
+  cout << "One factor of " << n << " is: " << result << endl;
+}

src/main.h

@@ -0,0 +1,7 @@
+#ifndef MAIN_H
+#define MAIN_H
+
+#include <iostream>
+#include "factor.h"
+
+#endif