FindAFactor 3.6.0__tar.gz → 3.6.2__tar.gz

{findafactor-3.6.0 → findafactor-3.6.2}/FindAFactor/_find_a_factor.cpp

@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //
-// (C) Daniel Strano and the Qrack contributors 2017-2024. All rights reserved.
+// (C) Daniel Strano and the Qrack contributors 2017-2025. All rights reserved.
 //
 // "A quantum-inspired Monte Carlo integer factoring algorithm"
 //
@@ -721,28 +721,6 @@ inline BigInteger modExp(BigInteger base, BigInteger exp, const BigInteger &mod)
   return result;
 }
 
-// Compute the prime factorization modulo 2
-boost::dynamic_bitset<size_t> factorizationVector(BigInteger num, const std::vector<BigInteger> &primes) {
-  boost::dynamic_bitset<size_t> vec(primes.size(), false);
-  for (size_t i = 0U; i < primes.size(); ++i) {
-    bool count = false;
-    const BigInteger &p = primes[i];
-    while (!(num % p)) {
-      num /= p;
-      count = !count;
-    }
-    vec[i] = count;
-    if (num == 1U) {
-      break;
-    }
-  }
-  if (num != 1U) {
-    return boost::dynamic_bitset<size_t>();
-  }
-
-  return vec;
-}
-
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //                                  WRITTEN WITH ELARA (GPT) ABOVE                                        //
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -751,6 +729,8 @@ struct Factorizer {
   std::mutex batchMutex;
   std::mutex smoothNumberMapMutex;
   std::default_random_engine rng;
+  std::mt19937_64 gen;
+  std::uniform_int_distribution<size_t> dis;
   BigInteger toFactorSqr;
   BigInteger toFactor;
   BigInteger toFactorSqrt;
@@ -758,22 +738,27 @@ struct Factorizer {
   BigInteger batchNumber;
   BigInteger batchOffset;
   BigInteger batchTotal;
+  BigInteger wheelRadius;
   size_t wheelEntryCount;
   size_t smoothPartsLimit;
   size_t rowOffset;
   bool isIncomplete;
   std::vector<BigInteger> primes;
+  std::vector<BigInteger> sqrPrimes;
   ForwardFn forwardFn;
   std::vector<BigInteger> smoothNumberKeys;
   std::vector<boost::dynamic_bitset<size_t>> smoothNumberValues;
 
   Factorizer(const BigInteger &tfsqr, const BigInteger &tf, const BigInteger &tfsqrt, const BigInteger &range, size_t nodeCount, size_t nodeId, size_t w, size_t spl,
              const std::vector<BigInteger> &p, ForwardFn fn)
-    : rng({}), toFactorSqr(tfsqr), toFactor(tf), toFactorSqrt(tfsqrt), batchRange(range), batchNumber(0U), batchOffset(nodeId * range), batchTotal(nodeCount * range),
-    wheelEntryCount(w), smoothPartsLimit(spl), rowOffset(p.size()), isIncomplete(true), primes(p), forwardFn(fn)
+    : rng({}), gen(rng()), dis(0U, p.size() - 1U), toFactorSqr(tfsqr), toFactor(tf), toFactorSqrt(tfsqrt), batchRange(range), batchNumber(0U), batchOffset(nodeId * range), batchTotal(nodeCount * range),
+    wheelRadius(1U), wheelEntryCount(w), smoothPartsLimit(spl), rowOffset(p.size()), isIncomplete(true), primes(p), forwardFn(fn)
   {
     for (size_t i = 0U; i < primes.size(); ++i) {
-      smoothNumberKeys.push_back(primes[i]);
+      const BigInteger& p = primes[i];
+      wheelRadius *= p;
+      sqrPrimes.push_back(p * p);
+      smoothNumberKeys.push_back(p);
       smoothNumberValues.emplace_back(primes.size(), false);
       smoothNumberValues.back()[i] = true;
     }
@@ -841,12 +826,39 @@ struct Factorizer {
     return 1U;
   }
 
+  // Compute the prime factorization modulo 2
+  boost::dynamic_bitset<size_t> factorizationVector(BigInteger num) {
+    boost::dynamic_bitset<size_t> vec(primes.size(), false);
+    BigInteger factor = 1U;
+    do {
+      factor = gcd(num, wheelRadius);
+      if (factor == 1U) {
+        break;
+      }
+      num /= factor;
+      for (size_t pi = 0U; pi < primes.size(); ++pi) {
+        if (!(factor % primes[pi])) {
+          vec[pi] = !vec[pi];
+        }
+      }
+      if (num == 1U) {
+        break;
+      }
+    } while (factor != 1U);
+
+    if (num != 1U) {
+      return boost::dynamic_bitset<size_t>();
+    }
+
+    return vec;
+  }
+
   void makeSmoothNumbers(std::vector<BigInteger> *semiSmoothParts, bool isGaussElim) {
     // Factorize all "smooth parts."
     std::vector<BigInteger> smoothParts;
     std::map<BigInteger, boost::dynamic_bitset<size_t>> smoothPartsMap;
     for (const BigInteger &n : (*semiSmoothParts)) {
-      const boost::dynamic_bitset<size_t> fv = factorizationVector(n, primes);
+      const boost::dynamic_bitset<size_t> fv = factorizationVector(n);
       if (fv.size()) {
         smoothPartsMap[n] = fv;
         smoothParts.push_back(n);
@@ -894,8 +906,7 @@ struct Factorizer {
     auto mColIt = smoothNumberValues.begin();
     auto nColIt = smoothNumberKeys.begin();
     const size_t rows = smoothNumberValues.size();
-    const size_t cols = mColIt->size();
-    for (size_t col = 0U; col < cols; ++col) {
+    for (size_t col = 0U; col < primes.size(); ++col) {
       auto mRowIt = mColIt;
       auto nRowIt = nColIt;
 
@@ -953,6 +964,32 @@ struct Factorizer {
     }
   }
 
+  BigInteger checkPerfectSquare(BigInteger perfectSquare) {
+    while (perfectSquare < toFactorSqr) {
+      // Compute x and y
+      const BigInteger x = perfectSquare % toFactor;
+      const BigInteger y = modExp(x, toFactor >> 1U, toFactor);
+
+      // Check congruence of squares
+      BigInteger factor = gcd(toFactor, x + y);
+      if ((factor != 1U) && (factor != toFactor)) {
+        return factor;
+      }
+
+      if (x != y) {
+        // Try x - y as well
+        factor = gcd(toFactor, x - y);
+        if ((factor != 1U) && (factor != toFactor)) {
+          return factor;
+        }
+      }
+
+      perfectSquare *= sqrPrimes[dis(gen)];
+    }
+
+    return 1U;
+  }
+
   // Find duplicate rows
   BigInteger findDuplicateRows(const BigInteger &target) {
     // Check for linear dependencies and find a congruence of squares
@@ -987,25 +1024,7 @@ struct Factorizer {
             toStrike.insert(i);
           }
 
-          // Compute x and y
-          const BigInteger x = (iInt * jInt) % target;
-          const BigInteger y = modExp(x, target >> 1U, target);
-
-          // Check congruence of squares
-          BigInteger factor = gcd(target, x + y);
-          if ((factor != 1U) && (factor != target)) {
-            std::lock_guard<std::mutex> lock(rowMutex);
-            result = factor;
-
-            return true;
-          }
-
-          if (x == y) {
-            continue;
-          }
-
-          // Try x - y as well
-          factor = gcd(target, x - y);
+          const BigInteger factor = checkPerfectSquare(this->smoothNumberKeys[i]);
           if ((factor != 1U) && (factor != target)) {
             std::lock_guard<std::mutex> lock(rowMutex);
             result = factor;
@@ -1047,27 +1066,8 @@ struct Factorizer {
     const size_t rowCount = smoothNumberKeys.size();
     for (size_t i = primes.size(); (i < rowCount) && (result == 1U); ++i) {
       dispatch.dispatch([this, &target, i, &result, &rowMutex]() -> bool {
-        const BigInteger& iInt = this->smoothNumberKeys[i];
-
-        // Compute x and y
-        const BigInteger x = iInt % target;
-        const BigInteger y = modExp(x, target >> 1U, target);
-
-        // Check congruence of squares
-        BigInteger factor = gcd(target, x + y);
-        if ((factor != 1U) && (factor != target)) {
-          std::lock_guard<std::mutex> lock(rowMutex);
-          result = factor;
+        const BigInteger factor = checkPerfectSquare(this->smoothNumberKeys[i]);
 
-          return true;
-        }
-
-        if (x == y) {
-          return false;
-        }
-
-        // Try x - y as well
-        factor = gcd(target, x - y);
         if ((factor != 1U) && (factor != target)) {
           std::lock_guard<std::mutex> lock(rowMutex);
           result = factor;

{findafactor-3.6.0 → findafactor-3.6.2}/FindAFactor.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FindAFactor
-Version: 3.6.0
+Version: 3.6.2
 Summary: Find any nontrivial factor of a number
 Home-page: https://github.com/vm6502q/FindAFactor
 Author: Dan Strano
@@ -23,7 +23,7 @@ Requires-Dist: pybind11
 Find any nontrivial factor of a number
 
 ## Copyright and license
-(c) Daniel Strano and the Qrack contributors 2017-2024. All rights reserved.
+(c) Daniel Strano and the Qrack contributors 2017-2025. All rights reserved.
 
 ## Installation
 From PyPi:

{findafactor-3.6.0 → findafactor-3.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FindAFactor
-Version: 3.6.0
+Version: 3.6.2
 Summary: Find any nontrivial factor of a number
 Home-page: https://github.com/vm6502q/FindAFactor
 Author: Dan Strano
@@ -23,7 +23,7 @@ Requires-Dist: pybind11
 Find any nontrivial factor of a number
 
 ## Copyright and license
-(c) Daniel Strano and the Qrack contributors 2017-2024. All rights reserved.
+(c) Daniel Strano and the Qrack contributors 2017-2025. All rights reserved.
 
 ## Installation
 From PyPi:

{findafactor-3.6.0 → findafactor-3.6.2}/README.md

@@ -2,7 +2,7 @@
 Find any nontrivial factor of a number
 
 ## Copyright and license
-(c) Daniel Strano and the Qrack contributors 2017-2024. All rights reserved.
+(c) Daniel Strano and the Qrack contributors 2017-2025. All rights reserved.
 
 ## Installation
 From PyPi:

{findafactor-3.6.0 → findafactor-3.6.2}/setup.py

@@ -7,7 +7,7 @@ except ImportError:
 import setuptools
 from distutils.core import setup, Extension
 
-cpp_args = ['-std=c++17', '-lpthread']
+cpp_args = ['-std=c++17', '-lpthread', '-O3']
 
 README_PATH = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'README.md')
 with open(README_PATH) as readme_file:
@@ -26,7 +26,7 @@ ext_modules = [
 
 setup(
     name='FindAFactor',
-    version='3.6.0',
+    version='3.6.2',
     author='Dan Strano',
     author_email='dan@unitary.fund',
     description='Find any nontrivial factor of a number',