FindAFactor 3.6.6__tar.gz → 3.6.8__tar.gz

{findafactor-3.6.6 → findafactor-3.6.8}/FindAFactor/_find_a_factor.cpp

@@ -189,7 +189,7 @@ inline size_t backward3(const size_t &n) { return (size_t)((~(~n | 1U)) / 3U) +
 constexpr unsigned char wheel5[8U] = {1U, 7U, 11U, 13U, 17U, 19U, 23U, 29U};
 
 // Make this NOT a multiple of 2, 3, or 5.
-size_t forward5(const size_t &p) { return wheel5[p % 8U] + (p / 8U) * 30U; }
+size_t forward5(const size_t &p) { return wheel5[p & 7U] + (p >> 3U) * 30U; }
 
 size_t backward5(const size_t &n) { return std::distance(wheel5, std::lower_bound(wheel5, wheel5 + 8U, (size_t)(n % 30U))) + 8U * (size_t)(n / 30U) + 1U; }
 
@@ -486,7 +486,7 @@ inline BigInteger _forward3(const BigInteger &p) { return (p << 1U) + (~(~p | 1U
 
 inline BigInteger _backward3(const BigInteger &n) { return ((~(~n | 1U)) / 3U) + 1U; }
 
-BigInteger _forward5(const BigInteger &p) { return wheel5[(size_t)(p % 8U)] + (p / 8U) * 30U; }
+BigInteger _forward5(const BigInteger &p) { return wheel5[(size_t)(p & 7U)] + (p >> 3U) * 30U; }
 
 BigInteger _backward5(const BigInteger &n) { return std::distance(wheel5, std::lower_bound(wheel5, wheel5 + 8U, (size_t)(n % 30U))) + 8U * (n / 30U) + 1U; }
 
@@ -682,7 +682,7 @@ bool isMultiple(const BigInteger &p, const std::vector<size_t> &knownPrimes) {
 
 boost::dynamic_bitset<size_t> wheel_inc(std::vector<size_t> primes) {
   BigInteger radius = 1U;
-  for (const BigInteger &i : primes) {
+  for (const size_t &i : primes) {
     radius *= i;
   }
   const size_t prime = primes.back();
@@ -769,7 +769,6 @@ struct Factorizer {
   size_t rowOffset;
   bool isIncomplete;
   std::vector<size_t> primes;
-  std::vector<size_t> sqrPrimes;
   ForwardFn forwardFn;
   std::vector<BigInteger> smoothNumberKeys;
   std::vector<boost::dynamic_bitset<size_t>> smoothNumberValues;
@@ -782,7 +781,6 @@ struct Factorizer {
     for (size_t i = 0U; i < primes.size(); ++i) {
       const size_t& p = primes[i];
       wheelRadius *= p;
-      sqrPrimes.push_back(p * p);
       smoothNumberKeys.push_back(p);
       smoothNumberValues.emplace_back(primes.size(), 0);
       smoothNumberValues.back()[i] = true;
@@ -875,7 +873,7 @@ struct Factorizer {
       if (num == 1U) {
         return vec;
       }
-    };
+    }
     if (num != 1U) {
       return boost::dynamic_bitset<size_t>();
     }
@@ -995,26 +993,24 @@ 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;
-      }
+    // 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;
-        }
-      }
+    if (x == y) {
+      return 1U;
+    }
 
-      perfectSquare *= sqrPrimes[dis(gen)];
+    // Try x - y as well
+    factor = gcd(toFactor, x - y);
+    if ((factor != 1U) && (factor != toFactor)) {
+      return factor;
     }
 
     return 1U;
@@ -1198,10 +1194,11 @@ std::string find_a_factor(const std::string &toFactorStr, const bool &isConOfSqr
   const size_t maxPrimeCount = std::min(primes.size(), smoothPrimeCount);
   std::vector<size_t> smoothPrimes;
   for (size_t primeId = 0U; (primeId < primes.size()) && (smoothPrimes.size() < maxPrimeCount); ++primeId) {
-    const size_t residue = (size_t)(toFactor % primes[primeId]);
+    const size_t p = primes[primeId];
+    const size_t residue = (size_t)(toFactor % p);
     const size_t sr = _sqrt(residue);
     if ((sr * sr) == residue) {
-      smoothPrimes.push_back(primes[primeId]);
+      smoothPrimes.push_back(p);
     }
   }
   if (smoothPrimes.size() < maxPrimeCount) {
@@ -1231,8 +1228,6 @@ std::string find_a_factor(const std::string &toFactorStr, const bool &isConOfSqr
 
   // Range per parallel node
   const BigInteger nodeRange = (((backward(SMALLEST_WHEEL)(fullMaxBase) + nodeCount - 1U) / nodeCount) + wheelEntryCount - 1U) / wheelEntryCount;
-  // This is used by all threads:
-  std::vector<std::vector<BigInteger>> semiSmoothParts(CpuCount);
   // This manages the work of all threads.
   Factorizer worker(toFactor * toFactor, toFactor, fullMaxBase,
                     nodeRange, nodeCount, nodeId,
@@ -1269,7 +1264,7 @@ std::string find_a_factor(const std::string &toFactorStr, const bool &isConOfSqr
     return boost::lexical_cast<std::string>(result);
   }
 
-  const auto smoothNumberFn = [&inc_seqs, &wheelEntryCount, &semiSmoothParts, &worker, &isGaussElim] (unsigned cpu) {
+  const auto smoothNumberFn = [&inc_seqs, &wheelEntryCount, &batchSizeMultiplier, &worker, &isGaussElim] {
     // inc_seq needs to be independent per thread.
     std::vector<boost::dynamic_bitset<size_t>> inc_seqs_clone;
     inc_seqs_clone.reserve(inc_seqs.size());
@@ -1278,10 +1273,11 @@ std::string find_a_factor(const std::string &toFactorStr, const bool &isConOfSqr
     }
 
     // Different collections per thread;
-    semiSmoothParts.reserve(wheelEntryCount << 1U);
+    std::vector<BigInteger> semiSmoothParts;
+    semiSmoothParts.reserve((size_t)((wheelEntryCount << 1U) * batchSizeMultiplier));
 
     // While brute-forcing, use the "exhaust" to feed "smooth" number generation and check conguence of squares.
-    return worker.smoothCongruences(&inc_seqs_clone, &(semiSmoothParts[cpu]), isGaussElim);
+    return worker.smoothCongruences(&inc_seqs_clone, &semiSmoothParts, isGaussElim);
   };
 
   std::vector<std::future<BigInteger>> futures;
@@ -1289,7 +1285,7 @@ std::string find_a_factor(const std::string &toFactorStr, const bool &isConOfSqr
 
   do {
     for (unsigned cpu = 0U; cpu < CpuCount; ++cpu) {
-      futures.push_back(std::async(std::launch::async, smoothNumberFn, cpu));
+      futures.push_back(std::async(std::launch::async, smoothNumberFn));
     }
 
     for (unsigned cpu = 0U; cpu < futures.size(); ++cpu) {

{findafactor-3.6.6 → findafactor-3.6.8}/FindAFactor.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FindAFactor
-Version: 3.6.6
+Version: 3.6.8
 Summary: Find any nontrivial factor of a number
 Home-page: https://github.com/vm6502q/FindAFactor
 Author: Dan Strano

{findafactor-3.6.6 → findafactor-3.6.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FindAFactor
-Version: 3.6.6
+Version: 3.6.8
 Summary: Find any nontrivial factor of a number
 Home-page: https://github.com/vm6502q/FindAFactor
 Author: Dan Strano

{findafactor-3.6.6 → findafactor-3.6.8}/setup.py

@@ -26,7 +26,7 @@ ext_modules = [
 
 setup(
     name='FindAFactor',
-    version='3.6.6',
+    version='3.6.8',
     author='Dan Strano',
     author_email='dan@unitary.fund',
     description='Find any nontrivial factor of a number',