FindAFactor 3.9.0__tar.gz → 4.1.0__tar.gz

findafactor-4.1.0/FindAFactor/__init__.py

@@ -0,0 +1 @@
+from .find_a_factor import find_a_factor, FactoringMethod

{findafactor-3.9.0 → findafactor-4.1.0}/FindAFactor/_find_a_factor.cpp

@@ -744,7 +744,6 @@ inline BigInteger modExp(BigInteger base, BigInteger exp, const BigInteger &mod)
 
 struct Factorizer {
   std::mutex batchMutex;
-  std::mutex smoothNumberMapMutex;
   std::default_random_engine rng;
   std::mt19937_64 gen;
   std::uniform_int_distribution<size_t> dis;
@@ -761,9 +760,10 @@ struct Factorizer {
   size_t rowOffset;
   bool isIncomplete;
   std::vector<size_t> primes;
+  std::vector<BigInteger> bigPrimes;
+  std::vector<BigInteger> sqrPrimes;
+  std::vector<boost::dynamic_bitset<size_t>> primeFactors;
   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<size_t> &p, ForwardFn fn)
@@ -773,9 +773,10 @@ struct Factorizer {
     for (size_t i = 0U; i < primes.size(); ++i) {
       const size_t& p = primes[i];
       wheelRadius *= p;
-      smoothNumberKeys.push_back(p);
-      smoothNumberValues.emplace_back(primes.size(), 0);
-      smoothNumberValues.back()[i] = true;
+      bigPrimes.push_back(p);
+      sqrPrimes.push_back(p * p);
+      primeFactors.emplace_back(primes.size(), 0);
+      primeFactors.back()[i] = true;
     }
   }
 
@@ -809,10 +810,15 @@ struct Factorizer {
     return 1U;
   }
 
-  BigInteger smoothCongruences(std::vector<boost::dynamic_bitset<size_t>> *inc_seqs, std::vector<BigInteger> *semiSmoothParts, bool isGaussElim) {
+  BigInteger smoothCongruences(std::vector<boost::dynamic_bitset<size_t>> *inc_seqs) {
     // Up to wheel factorization, try all batches up to the square root of toFactor.
     // Since the largest prime factors of these numbers is relatively small,
     // use the "exhaust" of brute force to produce smooth numbers for Quadratic Sieve.
+    // Different collections per thread;
+    std::map<BigInteger, boost::dynamic_bitset<size_t>> smoothPartsMap;
+    std::vector<BigInteger> smoothParts;
+    smoothParts.reserve(smoothPartsLimit);
+    BigInteger numberCount = 0;
     for (BigInteger batchNum = getNextAltBatch(); isIncomplete; batchNum = getNextAltBatch()) {
       const BigInteger batchStart = batchNum * wheelEntryCount;
       const BigInteger batchEnd = batchStart + wheelEntryCount;
@@ -825,16 +831,22 @@ struct Factorizer {
           return n;
         }
         // Use the "exhaust" to produce smoother numbers.
-        semiSmoothParts->push_back(n);
+        const boost::dynamic_bitset<size_t> fv = factorizationVector(n);
+        if (fv.size()) {
+            smoothPartsMap[n] = fv;
+            smoothParts.push_back(n);
+        }
         // Skip increments on the "wheels" (or "gears").
         p += GetWheelIncrement(inc_seqs);
       }
 
       // Batch this work, to reduce contention.
-      if (semiSmoothParts->size() >= smoothPartsLimit) {
-        makeSmoothNumbers(semiSmoothParts, isGaussElim);
-
-        return 1U;
+      if (smoothParts.size() >= smoothPartsLimit) {
+        const BigInteger n = makeSmoothNumbers(smoothParts, smoothPartsMap);
+        if (!(toFactor % n) && (n != 1U) && (n != toFactor)) {
+          isIncomplete = false;
+          return n;
+        }
       }
     }
 
@@ -873,28 +885,19 @@ struct Factorizer {
     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);
-      if (fv.size()) {
-        smoothPartsMap[n] = fv;
-        smoothParts.push_back(n);
-      }
-    }
-    // We can clear the thread's buffer vector.
-    semiSmoothParts->clear();
-
+  BigInteger makeSmoothNumbers(std::vector<BigInteger> &smoothParts, std::map<BigInteger, boost::dynamic_bitset<size_t>> &smoothPartsMap) {
     // This is the only nondeterminism in the algorithm.
     std::shuffle(smoothParts.begin(), smoothParts.end(), rng);
-
-    const BigInteger limit = isGaussElim ? toFactor : toFactorSqrt;
-
     // Now that smooth parts have been shuffled, just multiply down the list until they are larger than square root of toFactor.
     BigInteger smoothNumber = 1U;
     boost::dynamic_bitset<size_t> fv(primes.size(), 0);
+    std::vector<BigInteger> smoothNumberKeys(bigPrimes);
+    std::vector<boost::dynamic_bitset<size_t>> smoothNumberValues;
+    smoothNumberValues.reserve(primeFactors.size());
+    for (const auto& f : primeFactors) {
+      smoothNumberValues.emplace_back(f);
+    }
+    smoothNumberKeys.reserve(smoothParts.size());
     for (size_t spi = 0U; spi < smoothParts.size(); ++spi) {
       const BigInteger &sp = smoothParts[spi];
       // This multiplies together the factorizations of the smooth parts
@@ -902,18 +905,19 @@ struct Factorizer {
       fv ^= smoothPartsMap[sp];
       smoothNumber *= sp;
       // Check if the number is big enough
-      if (smoothNumber <= limit) {
+      if (smoothNumber <= toFactor) {
         continue;
       }
-      if (true) {
-        std::lock_guard<std::mutex> lock(smoothNumberMapMutex);
-        smoothNumberValues.emplace_back(fv);
-        smoothNumberKeys.push_back(smoothNumber);
-      }
+      smoothNumberValues.emplace_back(fv);
+      smoothNumberKeys.push_back(smoothNumber);
       // Reset "smoothNumber" and its factorization vector.
       smoothNumber = 1U;
       fv = boost::dynamic_bitset<size_t>(primes.size(), 0);
     }
+    smoothParts.clear();
+    smoothPartsMap.clear();
+
+    return findFactor(smoothNumberKeys, smoothNumberValues);
   }
 
   ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -921,7 +925,7 @@ struct Factorizer {
   ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
   // Perform Gaussian elimination on a binary matrix
-  void gaussianElimination() {
+  void gaussianElimination(std::vector<BigInteger> &smoothNumberKeys, std::vector<boost::dynamic_bitset<size_t>> &smoothNumberValues) {
     const unsigned cpuCount = CpuCount;
     auto mColIt = smoothNumberValues.begin();
     auto nColIt = smoothNumberKeys.begin();
@@ -985,108 +989,48 @@ struct Factorizer {
   }
 
   BigInteger checkPerfectSquare(BigInteger perfectSquare) {
-    // 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) {
-      return 1U;
-    }
-
-    // Try x - y as well
-    factor = gcd(toFactor, x - y);
-    if ((factor != 1U) && (factor != toFactor)) {
-      return factor;
-    }
-
-    return 1U;
-  }
-
-  // Find duplicate rows
-  BigInteger findDuplicateRows(const BigInteger &target) {
-    // Check for linear dependencies and find a congruence of squares
-    std::mutex rowMutex;
-    BigInteger result = 1U;
-    std::set<size_t> toStrike;
-    auto iIt = smoothNumberValues.begin();
-    const size_t rowCount = smoothNumberValues.size();
-    const size_t rowCountMin1 = rowCount - 1U;
-    for (size_t i = primes.size(); (i < rowCountMin1) && (result == 1U); ++i) {
-      dispatch.dispatch([this, &target, i, iIt, &rowCount, &result, &rowMutex, &toStrike]() -> bool {
-        boost::dynamic_bitset<size_t> &iRow = *iIt;
-        const BigInteger& iInt = this->smoothNumberKeys[i];
-
-        const size_t startJ = std::max(this->rowOffset, i + 1U);
-        auto jIt = this->smoothNumberValues.begin();
-        std::advance(jIt, (startJ - 1U));
-        for (size_t j = startJ; j < rowCount; ++j) {
-          ++jIt;
-
-          boost::dynamic_bitset<size_t> &jRow = *jIt;
-          if (iRow != jRow) {
-            continue;
-          }
-
-          const BigInteger& jInt = this->smoothNumberKeys[j];
-          if (iInt < jInt) {
-            std::lock_guard<std::mutex> lock(rowMutex);
-            toStrike.insert(j);
-          } else {
-            std::lock_guard<std::mutex> lock(rowMutex);
-            toStrike.insert(i);
-          }
-
-          const BigInteger factor = checkPerfectSquare(this->smoothNumberKeys[i]);
-          if ((factor != 1U) && (factor != target)) {
-            std::lock_guard<std::mutex> lock(rowMutex);
-            result = factor;
-
-            return true;
-          }
-        }
+    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;
+      }
 
-        return false;
-      });
-      ++iIt;
-    }
-    dispatch.finish();
+      if (x == y) {
+        continue;
+      }
 
-    if (result != 1U) {
-      return result;
-    }
+      // Try x - y as well
+      factor = gcd(toFactor, x - y);
+      if ((factor != 1U) && (factor != toFactor)) {
+        return factor;
+      }
 
-    // These numbers have been tried already:
-    for (const size_t& i : toStrike) {
-      smoothNumberKeys.erase(smoothNumberKeys.begin() + i);
-      smoothNumberValues.erase(smoothNumberValues.begin() + i);
+      perfectSquare *= sqrPrimes[dis(gen)];
     }
 
-    rowOffset = smoothNumberKeys.size();
-
-    return 1U; // No factor found
+    return 1U;
   }
 
   // Use Gaussian elimination
-  BigInteger findFactor(const BigInteger &target) {
+  BigInteger findFactor(std::vector<BigInteger> &smoothNumberKeys, std::vector<boost::dynamic_bitset<size_t>> &smoothNumberValues) {
     // Gaussian elimination multiplies these numbers
     // with small primes, to produce squares
-    gaussianElimination();
+    gaussianElimination(smoothNumberKeys, smoothNumberValues);
 
     // Check for linear dependencies and find a congruence of squares
     std::mutex rowMutex;
     BigInteger result = 1U;
     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 factor = checkPerfectSquare(this->smoothNumberKeys[i]);
+      dispatch.dispatch([this, i, &result, &rowMutex, &smoothNumberKeys]() -> bool {
+        const BigInteger factor = checkPerfectSquare(smoothNumberKeys[i]);
 
-        if ((factor != 1U) && (factor != target)) {
+        if ((factor != 1U) && (factor != this->toFactor)) {
           std::lock_guard<std::mutex> lock(rowMutex);
           result = factor;
 
@@ -1114,9 +1058,13 @@ struct Factorizer {
   ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 };
 
-std::string find_a_factor(const std::string &toFactorStr, const bool &isConOfSqr, const bool &isGaussElim, const size_t &nodeCount, const size_t &nodeId,
-                          size_t trialDivisionLevel, size_t gearFactorizationLevel, size_t wheelFactorizationLevel, double smoothnessBoundMultiplier, double batchSizeMultiplier) {
+std::string find_a_factor(std::string toFactorStr, size_t method, size_t nodeCount, size_t nodeId, size_t trialDivisionLevel, size_t gearFactorizationLevel,
+                          size_t wheelFactorizationLevel, double smoothnessBoundMultiplier, double batchSizeMultiplier) {
   // (At least) level 11 wheel factorization is baked into basic functions.
+  if (method > 1U) {
+    std::cout << "FACTOR_FINDER mode not yet implemented. Defaulting to MIXED." << std::endl;
+  }
+  const bool isConOfSqr = (method > 0);
   if (!wheelFactorizationLevel) {
     wheelFactorizationLevel = 1U;
   } else if (wheelFactorizationLevel > 13U) {
@@ -1256,7 +1204,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, &batchSizeMultiplier, &worker, &isGaussElim] {
+  const auto workerFn = [&inc_seqs, &wheelEntryCount, &batchSizeMultiplier, &worker] {
     // 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());
@@ -1264,38 +1212,23 @@ std::string find_a_factor(const std::string &toFactorStr, const bool &isConOfSqr
       inc_seqs_clone.emplace_back(b);
     }
 
-    // Different collections per thread;
-    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, isGaussElim);
+    return worker.smoothCongruences(&inc_seqs_clone);
   };
 
   std::vector<std::future<BigInteger>> futures;
   futures.reserve(CpuCount);
 
-  do {
-    for (unsigned cpu = 0U; cpu < CpuCount; ++cpu) {
-      futures.push_back(std::async(std::launch::async, smoothNumberFn));
-    }
-
-    for (unsigned cpu = 0U; cpu < futures.size(); ++cpu) {
-      const BigInteger r = futures[cpu].get();
-      if ((r > result) && (r != toFactor)) {
-        result = r;
-      }
-    }
+  for (unsigned cpu = 0U; cpu < CpuCount; ++cpu) {
+    futures.push_back(std::async(std::launch::async, workerFn));
+  }
 
-    if ((result != 1U) && (result != toFactor)) {
-      return boost::lexical_cast<std::string>(result);
+  for (unsigned cpu = 0U; cpu < futures.size(); ++cpu) {
+    const BigInteger r = futures[cpu].get();
+    if ((r > result) && (r != toFactor)) {
+      result = r;
     }
-
-    futures.clear();
-
-    // This next section is for (Quadratic Sieve) Gaussian elimination.
-    result = isGaussElim ? worker.findFactor(toFactor) : worker.findDuplicateRows(toFactor);
-  } while ((result == 1U) || (result == toFactor));
+  }
 
   return boost::lexical_cast<std::string>(result);
 }
@@ -1305,5 +1238,5 @@ using namespace Qimcifa;
 
 PYBIND11_MODULE(_find_a_factor, m) {
   m.doc() = "pybind11 plugin to find any factor of input";
-  m.def("_find_a_factor", &find_a_factor, "Finds any nontrivial factor of input (or returns 1 if prime)");
+  m.def("_find_a_factor", &find_a_factor, "Finds any nontrivial factor of input (or returns 1 or the number to factor if prime)");
 }

{findafactor-3.9.0 → findafactor-4.1.0}/FindAFactor/find_a_factor.py

@@ -1,19 +1,25 @@
 import os
 import _find_a_factor
+from enum import IntEnum
+
+
+class FactoringMethod(IntEnum):
+    PRIME_SOLVER = 0
+    MIXED = 1
+    FACTOR_FINDER = 2
+
 
 def find_a_factor(n,
-                  use_congruence_of_squares=True if os.environ.get('FINDAFACTOR_USE_CONGRUENCE_OF_SQUARES') else False,
-                  use_gaussian_elimination=True if os.environ.get('FINDAFACTOR_USE_GAUSSIAN_ELIMINATION') else False,
+                  method=FactoringMethod(int(os.environ.get('FINDAFACTOR_METHOD'))) if os.environ.get('FINDAFACTOR_METHOD') else FactoringMethod.PRIME_SOLVER,
                   node_count=int(os.environ.get('FINDAFACTOR_NODE_COUNT')) if os.environ.get('FINDAFACTOR_NODE_COUNT') else 1,
                   node_id=int(os.environ.get('FINDAFACTOR_NODE_ID')) if os.environ.get('FINDAFACTOR_NODE_ID') else 0,
                   trial_division_level=int(os.environ.get('FINDAFACTOR_TRIAL_DIVISION_LEVEL')) if os.environ.get('FINDAFACTOR_TRIAL_DIVISION_LEVEL') else (1<<20),
                   gear_factorization_level=int(os.environ.get('FINDAFACTOR_GEAR_FACTORIZATION_LEVEL')) if os.environ.get('FINDAFACTOR_GEAR_FACTORIZATION_LEVEL') else 11,
-                  wheel_factorization_level=int(os.environ.get('FINDAFACTOR_WHEEL_FACTORIZATION_LEVEL')) if os.environ.get('FINDAFACTOR_WHEEL_FACTORIZATION_LEVEL') else 7,
-                  smoothness_bound_multiplier=float(os.environ.get('FINDAFACTOR_SMOOTHNESS_BOUND_MULTIPLIER')) if os.environ.get('FINDAFACTOR_SMOOTHNESS_BOUND_MULTIPLIER') else 1.0,
-                  batch_size_multiplier=float(os.environ.get('FINDAFACTOR_BATCH_SIZE_MULTIPLIER')) if os.environ.get('FINDAFACTOR_BATCH_SIZE_MULTIPLIER') else 2048.0):
+                  wheel_factorization_level=int(os.environ.get('FINDAFACTOR_WHEEL_FACTORIZATION_LEVEL')) if os.environ.get('FINDAFACTOR_WHEEL_FACTORIZATION_LEVEL') else 11,
+                  smoothness_bound_multiplier=float(os.environ.get('FINDAFACTOR_SMOOTHNESS_BOUND_MULTIPLIER')) if os.environ.get('FINDAFACTOR_SMOOTHNESS_BOUND_MULTIPLIER') else 0.25,
+                  batch_size_multiplier=float(os.environ.get('FINDAFACTOR_BATCH_SIZE_MULTIPLIER')) if os.environ.get('FINDAFACTOR_BATCH_SIZE_MULTIPLIER') else 8.0):
     return int(_find_a_factor._find_a_factor(str(n),
-                                             use_congruence_of_squares,
-                                             use_gaussian_elimination,
+                                             int(method),
                                              node_count, node_id,
                                              trial_division_level,
                                              gear_factorization_level,

{findafactor-3.9.0 → findafactor-4.1.0}/FindAFactor.egg-info/PKG-INFO

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

{findafactor-3.9.0 → findafactor-4.1.0}/FindAFactor.egg-info/SOURCES.txt

@@ -6,7 +6,6 @@ FindAFactor/__init__.py
 FindAFactor/_find_a_factor.cpp
 FindAFactor/dispatchqueue.cpp
 FindAFactor/find_a_factor.py
-FindAFactor/oclengine.cpp
 FindAFactor.egg-info/PKG-INFO
 FindAFactor.egg-info/SOURCES.txt
 FindAFactor.egg-info/dependency_links.txt

{findafactor-3.9.0 → findafactor-4.1.0}/PKG-INFO

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

{findafactor-3.9.0 → findafactor-4.1.0}/README.md

@@ -21,37 +21,35 @@ Windows users might find Windows Subsystem Linux (WSL) to be the easier and pref
 ## Usage
 
 ```py
-from FindAFactor import find_a_factor
+from FindAFactor import find_a_factor, FactoringMethod
 
 to_factor = 1000
 
 factor = find_a_factor(
     to_factor,
-    use_congruence_of_squares=False,
-    use_gaussian_elimination=False,
+    method=FactoringMethod.PRIME_SOLVER,
     node_count=1, node_id=0,
     trial_division_level=2**20,
     gear_factorization_level=11,
     wheel_factorization_level=11,
-    smoothness_bound_multiplier=1.0,
-    batch_size_multiplier=2048.0
+    smoothness_bound_multiplier=0.25,
+    batch_size_multiplier=8.0
 )
 ```
 
 The `find_a_factor()` function should return any nontrivial factor of `to_factor` (that is, any factor besides `1` or `to_factor`) if it exists. If a nontrivial factor does _not_ exist (i.e., the number to factor is prime), the function will return `1` or the original `to_factor`.
 
-- `use_congruence_of_squares` (default value: `False`): This attempts to check congruence of squares with "smooth" numbers, if `true`.
-- `use_gaussian_elimination` (default value: `False`): This option is only relevant if `use_congruence_of_squares=True`. In that case, if `use_gaussian_elimination` is `True`, then proper Gaussian elimination is used, with **O(N^3)** worst case complexity but using potentially much smaller "N" count of rows. If the option is `False`, rather than Gaussian elimination, the algorithm checks only for exact factorization parity duplicates in the "smooth" number rows, for **O(N^2)** worst case complexity, but using a potentially much larger "N" count of rows.
+- `method` (default value: `PRIME_SOLVER`/`0`): `PRIME_SOLVER`/`0` will prove that a number is prime (by failing to find any factors with wheel and gear factorization). `FACTOR_SOLVER`/`2` is optimized for the assumption that the number has at least two nontrivial factors. (`FACTOR_SOLVER`/`2` is not yet implemented, but this is the next development goal.) `MIXED`/`1` will be able to demonstrate that a number is prime, if necessary, while imitating some of the optimized behavior of `FACTOR_SOLVER`/`2`.
 - `node_count` (default value: `1`): `FindAFactor` can perform factorization in a _distributed_ manner, across nodes, without network communication! When `node_count` is set higher than `1`, the search space for factors is segmented equally per node. If the number to factor is semiprime, and brute-force search is used instead of congruence of squares, for example, all nodes except the one that happens to contain the (unknown) prime factor less than the square root of `to_factor` will ultimately return `1`, while one node will find and return this factor. For best performance, every node involved in factorization should have roughly the same CPU throughput capacity.
 - `node_id` (default value: `0`): This is the identifier of this node, when performing distributed factorization with `node_count` higher than `1`. `node_id` values start at `0` and go as high as `(node_count - 1)`.
 - `trial_division_level` (default value: `2**20`): Trial division is carried out as a preliminary round for all primes up this number. If you need more primes for your smoothness bound, increase this level.
 - `gear_factorization_level` (default value: `11`): This is the value up to which "wheel (and gear) factorization" and trial division are used to check factors and optimize "brute force," in general. The default value of `11` includes all prime factors of `11` and below and works well in general, though significantly higher might be preferred in certain cases.
 - `wheel_factorization_level` (default value: `11`): "Wheel" vs. "gear" factorization balances two types of factorization wheel ("wheel" vs. "gear" design) that often work best when the "wheel" is only a few prime number levels lower than gear factorization. Optimized implementation for wheels is only available up to `13`. The primes above "wheel" level, up to "gear" level, are the primes used specifically for "gear" factorization.
-- `smoothness_bound_multiplier` (default value: `1.0`): starting with the first prime number after wheel factorization, the congruence of squares approach (with Quadratic Sieve) takes a default "smoothness bound" with as many distinct prime numbers as bits in the number to factor (for default argument of `1.0` multiplier). To increase or decrease this number, consider it multiplied by the value of `smoothness_bound_multiplier`.
-- `batch_size_multiplier` (default value: `2048.0`): Each `1.0` increment of the multiplier is 2 cycles of gear and wheel factorization, alternating every other cycle between bottom of guessing range and top of guessing range, for every thread in use.
+- `smoothness_bound_multiplier` (default value: `0.25`): starting with the first prime number after wheel factorization, the congruence of squares approach (with Quadratic Sieve) has a "smoothness bound" unit with as many distinct prime numbers as bits in the number to facto0r (for argument of `1.0` multiplier). To increase or decrease this number, consider it multiplied by the value of `smoothness_bound_multiplier`.
+- `batch_size_multiplier` (default value: `8.0`): Each `1.0` increment of the multiplier is 2 cycles of gear and wheel factorization, alternating every other cycle between bottom of guessing range and top of guessing range, for every thread in use.
 
 All variables defaults can also be controlled by environment variables:
-- `FINDAFACTOR_USE_CONGRUENCE_OF_SQUARES` (any value makes `True`, while default is `False`)
+- `FINDAFACTOR_METHOD` (integer value)
 - `FINDAFACTOR_NODE_COUNT`
 - `FINDAFACTOR_NODE_ID`
 - `FINDAFACTOR_TRIAL_DIVISION_LEVEL`

{findafactor-3.9.0 → findafactor-4.1.0}/pyproject.toml

@@ -2,17 +2,13 @@
 requires = [
     "cmake",
     "pybind11",
-    "setuptools",
-    "scikit-build"
+    "setuptools"
 ]
-build-backend = "scikit_build.build"
-
-[tool.scikit-build]
-cmake.args = ["-DCMAKE_BUILD_TYPE=Release"]
+build-backend = "setuptools.build_meta"
 
 [project]
 name = "FindAFactor"
-version = "3.9.0"
+version = "4.1.0"
 requires-python = ">=3.8"
 description = "Find any nontrivial factor of a number"
 readme = {file = "README.txt", content-type = "text/markdown"}

{findafactor-3.9.0 → findafactor-4.1.0}/setup.py

@@ -40,7 +40,7 @@ ext_modules = [CMakeExtension('_find_a_factor')]
 
 setup(
     name='FindAFactor',
-    version='3.9.0',
+    version='4.1.0',
     author='Dan Strano',
     author_email='stranoj@gmail.com',
     description='Find any nontrivial factor of a number',

findafactor-3.9.0/FindAFactor/__init__.py

@@ -1 +0,0 @@
-from .find_a_factor import find_a_factor

findafactor-3.9.0/FindAFactor/oclengine.cpp

@@ -1,386 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////////////
-//
-// (C) Daniel Strano and the Qrack contributors 2017-2023. All rights reserved.
-//
-// This is a multithreaded, universal quantum register simulation, allowing
-// (nonphysical) register cloning and direct measurement of probability and
-// phase, to leverage what advantages classical emulation of qubits can have.
-//
-// Licensed under the GNU Lesser General Public License V3.
-// See LICENSE.md in the project root or https://www.gnu.org/licenses/lgpl-3.0.en.html
-// for details.
-
-#include "oclengine.hpp"
-
-#include <algorithm>
-#include <iostream>
-#include <regex>
-#include <sstream>
-
-namespace Qimcifa {
-
-/// "Qrack::OCLEngine" manages the single OpenCL context
-
-// Public singleton methods to get pointers to various methods
-DeviceContextPtr OCLEngine::GetDeviceContextPtr(const int64_t& dev)
-{
-    if ((dev >= GetDeviceCount()) || (dev < -1) || (dev >= ((int64_t)all_device_contexts.size()))) {
-        throw std::invalid_argument("Invalid OpenCL device selection");
-    } else if (dev == -1) {
-        return default_device_context;
-    } else {
-        return all_device_contexts[dev];
-    }
-}
-
-// clang-format off
-const std::vector<OCLKernelHandle> OCLEngine::kernelHandles{
-    OCLKernelHandle(OCL_API_FACTORIZE_SMOOTH, "factorize")
-};
-// clang-format on
-
-const std::string OCLEngine::binary_file_prefix("ocl_dev_");
-const std::string OCLEngine::binary_file_ext(".ir");
-
-std::vector<DeviceContextPtr> OCLEngine::GetDeviceContextPtrVector() { return all_device_contexts; }
-void OCLEngine::SetDeviceContextPtrVector(std::vector<DeviceContextPtr> vec, DeviceContextPtr dcp)
-{
-    all_device_contexts = vec;
-    if (dcp != nullptr) {
-        default_device_context = dcp;
-    }
-}
-
-void OCLEngine::SetDefaultDeviceContext(DeviceContextPtr dcp) { default_device_context = dcp; }
-
-cl::Program OCLEngine::MakeProgram(const size_t bitPow, std::shared_ptr<OCLDeviceContext> devCntxt)
-{
-    // Load and build kernel
-    std::string kernelSourceStr =
-        "#define BCAPPOW " + std::to_string(bitPow) + "\n" +
-        "#define BIG_INTEGER_WORD_BITS 64U\n" +
-        "#define BIG_INTEGER_WORD_POWER 6U\n" +
-        "#define BIG_INTEGER_WORD ulong\n" +
-        "#define BIG_INTEGER_HALF_WORD uint\n" +
-        "#define BIG_INTEGER_HALF_WORD_MASK 0xFFFFFFFFULL\n" +
-        "#define BIG_INTEGER_HALF_WORD_MASK_NOT 0xFFFFFFFF00000000ULL\n" +
-        "\n" +
-        "// This can be any power of 2 greater than (or equal to) 64:\n" +
-        "const size_t BIG_INTEGER_BITS = (1 << BCAPPOW);\n" +
-        "const int BIG_INTEGER_WORD_SIZE = BIG_INTEGER_BITS / BIG_INTEGER_WORD_BITS;\n" +
-        "\n" +
-        "// The rest of the constants need to be consistent with the one above:\n" +
-        "const size_t BIG_INTEGER_HALF_WORD_BITS = BIG_INTEGER_WORD_BITS >> 1U;\n" +
-        "const int BIG_INTEGER_HALF_WORD_SIZE = BIG_INTEGER_WORD_SIZE << 1U;\n" +
-        "const int BIG_INTEGER_MAX_WORD_INDEX = BIG_INTEGER_WORD_SIZE - 1U;\n" +
-        "\n" +
-        "typedef struct BigInteger {\n" +
-        "    BIG_INTEGER_WORD bits[BIG_INTEGER_WORD_SIZE];\n" +
-        "} BigInteger;\n" +
-        "\n" +
-        "inline void set(const BigInteger* o, BigInteger* n)\n" +
-        "{\n" +
-        "    for (int i = 0; i < BIG_INTEGER_WORD_SIZE; ++i) {\n" +
-        "        n->bits[i] = o->bits[i];\n" +
-        "    }\n" +
-        "}\n" +
-        "\n" +
-        "inline void set_0(BigInteger* n)\n" +
-        "{\n" +
-        "    for (int i = 0; i < BIG_INTEGER_WORD_SIZE; ++i) {\n" +
-        "        n->bits[i] = 0U;\n" +
-        "    }\n" +
-        "}\n" +
-        "\n" +
-        "inline void xor_bit(const BIG_INTEGER_HALF_WORD b, BigInteger* o) {\n" +
-        "    o->bits[b % BIG_INTEGER_WORD_BITS] ^= (1ULL << (b / BIG_INTEGER_WORD_BITS));\n" +
-        "}\n" +
-        "inline int bi_compare_1(const BigInteger* left)\n" +
-        "{\n" +
-        "    for (int i = BIG_INTEGER_MAX_WORD_INDEX; i > 0; --i) {\n" +
-        "        if (left->bits[i]) {\n" +
-        "            return 1;\n" +
-        "        }\n" +
-        "    }\n" +
-        "    if (left->bits[0] > 1U) {\n" +
-        "        return 1;\n" +
-        "    }\n" +
-        "    if (left->bits[0] < 1U) {\n" +
-        "        return -1;\n" +
-        "    }\n" +
-        "\n" +
-        "    return 0;\n" +
-        "}\n" +
-        "\n" +
-        "// \"Schoolbook division\" (on half words)\n" +
-        "// Complexity - O(x^2)\n" +
-        "void bi_div_mod_small(\n" +
-        "    const BigInteger* left, BIG_INTEGER_HALF_WORD right, BigInteger* quotient, BIG_INTEGER_HALF_WORD* rmndr)\n" +
-        "{\n" +
-        "    BIG_INTEGER_WORD carry = 0U;\n" +
-        "    if (quotient) {\n" +
-        "        set_0(quotient);\n" +
-        "        for (int i = BIG_INTEGER_HALF_WORD_SIZE - 1; i >= 0; --i) {\n" +
-        "            const int i2 = i >> 1;\n" +
-        "            carry <<= BIG_INTEGER_HALF_WORD_BITS;\n" +
-        "            if (i & 1) {\n" +
-        "                carry |= left->bits[i2] >> BIG_INTEGER_HALF_WORD_BITS;\n" +
-        "                quotient->bits[i2] |= (carry / right) << BIG_INTEGER_HALF_WORD_BITS;\n" +
-        "            } else {\n" +
-        "                carry |= left->bits[i2] & BIG_INTEGER_HALF_WORD_MASK;\n" +
-        "                quotient->bits[i2] |= (carry / right);\n" +
-        "            }\n" +
-        "            carry %= right;\n" +
-        "        }\n" +
-        "    } else {\n" +
-        "        for (int i = BIG_INTEGER_HALF_WORD_SIZE - 1; i >= 0; --i) {\n" +
-        "            const int i2 = i >> 1;\n" +
-        "            carry <<= BIG_INTEGER_HALF_WORD_BITS;\n" +
-        "            if (i & 1) {\n" +
-        "                carry |= left->bits[i2] >> BIG_INTEGER_HALF_WORD_BITS;\n" +
-        "            } else {\n" +
-        "                carry |= left->bits[i2] & BIG_INTEGER_HALF_WORD_MASK;\n" +
-        "            }\n" +
-        "            carry %= right;\n" +
-        "        }\n" +
-        "    }\n" +
-        "\n" +
-        "    *rmndr = carry;\n" +
-        "}\n" +
-        "\n" +
-        "__kernel void factorize(\n" +
-        "    __global const BigInteger *numbers,                    // Array of numbers to check\n" +
-        "    __global const int *primes,                            // Array of small primes for smoothness\n" +
-        "    __global bool *results,                                // Output: 1 if smooth, 0 if not\n" +
-        "    __global const BigInteger *factor_vectors,             // Output: Factorization vectors as bitmasks\n" +
-        "    const int primeCount                                   // Number of primes in the array\n" +
-        ") {\n" +
-        "    int gid = get_global_id(0);                            // Get the index of this work item\n" +
-        "    BigInteger number, factor_vector, q;\n" +
-        "    set(&numbers[gid], &number);                           // The number to check\n" +
-        "    set_0(&factor_vector);                                 // Initialize the factor vector as 0\n" +
-        "\n" +
-        "    // Test divisibility by each prime\n" +
-        "    for (int i = 0; i < primeCount; ++i) {\n" +
-        "        const uint p = (uint)primes[i];\n" +
-        "        do {\n" +
-        "            unsigned int r = 0U;\n" +
-        "            bi_div_mod_small(&number, p, &q, &r);\n" +
-        "            if (r) {\n" +
-        "                break;"
-        "            }\n" +
-        "            set(&q, &number);\n" +
-        "            xor_bit(i, &factor_vector);                    // Flip the corresponding bit\n" +
-        "        } while (true);\n" +
-        "    }\n" +
-        "\n" +
-        "    // If number is reduced to 1, it is smooth\n" +
-        "    results[gid] = bi_compare_1(&number) == 0;\n" +
-        "\n" +
-        "    // Store the factor vector\n" +
-        "    set(&factor_vector, &(factor_vectors[gid]));\n" +
-        "}\n";
-
-    cl::Program::Sources sources;
-    sources.push_back({(const char*)kernelSourceStr.c_str(), (long unsigned int)(kernelSourceStr.size() + 1U) });
-
-    cl::Program program = cl::Program(devCntxt->context, sources);
-    std::cout << "Building JIT." << std::endl;
-
-    return program;
-}
-
-void OCLEngine::SaveBinary(cl::Program program, std::string path, std::string fileName)
-{
-    std::vector<size_t> clBinSizes = program.getInfo<CL_PROGRAM_BINARY_SIZES>();
-    size_t clBinSize = 0U;
-    int64_t clBinIndex = 0;
-
-    for (size_t i = 0U; i < clBinSizes.size(); ++i) {
-        if (clBinSizes[i]) {
-            clBinSize = clBinSizes[i];
-            clBinIndex = i;
-            break;
-        }
-    }
-
-    std::cout << "Binary size:" << clBinSize << std::endl;
-
-#if defined(_WIN32) && !defined(__CYGWIN__)
-    int err = _mkdir(path.c_str());
-#else
-    int err = mkdir(path.c_str(), 0700);
-#endif
-    if (err != -1) {
-        std::cout << "Making directory: " << path << std::endl;
-    }
-
-    FILE* clBinFile = fopen((path + fileName).c_str(), "w");
-    std::vector<std::vector<unsigned char>> clBinaries = program.getInfo<CL_PROGRAM_BINARIES>();
-    std::vector<unsigned char> clBinary = clBinaries[clBinIndex];
-    fwrite(&clBinary[0U], clBinSize, sizeof(unsigned char), clBinFile);
-    fclose(clBinFile);
-}
-
-InitOClResult OCLEngine::InitOCL(const size_t bitPow, std::vector<int64_t> maxAllocVec)
-{
-    if (!bitPow) {
-        throw std::runtime_error("Cannot InitOCL with default of 0 bits!");
-    }
-    // get all platforms (drivers), e.g. NVIDIA
-
-    std::vector<cl::Platform> all_platforms;
-    std::vector<cl::Device> all_devices;
-    std::vector<int64_t> device_platform_id;
-    cl::Platform default_platform;
-    cl::Device default_device;
-    std::vector<DeviceContextPtr> all_dev_contexts;
-    DeviceContextPtr default_dev_context;
-
-    cl::Platform::get(&all_platforms);
-
-    if (all_platforms.empty()) {
-        std::cout << " No platforms found. Check OpenCL installation!\n";
-        return InitOClResult();
-    }
-
-    // get all devices
-    std::vector<cl::Platform> devPlatVec;
-    std::vector<std::vector<cl::Device>> all_platforms_devices;
-    std::vector<bool> all_devices_is_gpu;
-    std::vector<bool> all_devices_is_cpu;
-    for (size_t i = 0U; i < all_platforms.size(); ++i) {
-        all_platforms_devices.push_back(std::vector<cl::Device>());
-        all_platforms[i].getDevices(CL_DEVICE_TYPE_ALL, &(all_platforms_devices[i]));
-        for (size_t j = 0U; j < all_platforms_devices[i].size(); ++j) {
-            // VirtualCL seems to break if the assignment constructor of cl::Platform is used here from the original
-            // list. Assigning the object from a new query is always fine, though. (They carry the same underlying
-            // platform IDs.)
-            std::vector<cl::Platform> temp_platforms;
-            cl::Platform::get(&temp_platforms);
-            devPlatVec.push_back(temp_platforms[i]);
-            device_platform_id.push_back(i);
-        }
-        all_devices.insert(all_devices.end(), all_platforms_devices[i].begin(), all_platforms_devices[i].end());
-
-        // Linux implements `cl::Device` relation operators, including equality, but Mac considers OpenCL "deprecated,"
-        // and other compilers might not see a strict need in OpenCL implementation standard for a `cl::Device` equality
-        // operator, which would allow the use of `std::find()`.
-        std::vector<cl::Device> gpu_devices;
-        all_platforms[i].getDevices(CL_DEVICE_TYPE_GPU, &gpu_devices);
-        std::vector<bool> gpu_to_insert(all_platforms_devices[i].size(), false);
-        for (size_t j = 0U; j < gpu_devices.size(); ++j) {
-            for (size_t k = 0U; k < all_platforms_devices[i].size(); ++k) {
-                if (gpu_devices[j].getInfo<CL_DEVICE_NAME>() == all_platforms_devices[i][j].getInfo<CL_DEVICE_NAME>()) {
-                    // Assuming all devices with the same name are identical vendor, line, and model, this works.
-                    gpu_to_insert[k] = true;
-                }
-            }
-        }
-        all_devices_is_gpu.insert(all_devices_is_gpu.end(), gpu_to_insert.begin(), gpu_to_insert.end());
-
-        std::vector<cl::Device> cpu_devices;
-        all_platforms[i].getDevices(CL_DEVICE_TYPE_CPU, &cpu_devices);
-        std::vector<bool> cpu_to_insert(all_platforms_devices[i].size(), false);
-        for (size_t j = 0U; j < cpu_devices.size(); ++j) {
-            for (size_t k = 0U; k < all_platforms_devices[i].size(); ++k) {
-                if (cpu_devices[j].getInfo<CL_DEVICE_NAME>() == all_platforms_devices[i][j].getInfo<CL_DEVICE_NAME>()) {
-                    // Assuming all devices with the same name are identical vendor, line, and model, this works.
-                    cpu_to_insert[k] = true;
-                }
-            }
-        }
-        all_devices_is_cpu.insert(all_devices_is_cpu.end(), cpu_to_insert.begin(), cpu_to_insert.end());
-    }
-    if (all_devices.empty()) {
-        std::cout << " No devices found. Check OpenCL installation!\n";
-        return InitOClResult();
-    }
-
-    int64_t deviceCount = all_devices.size();
-    // prefer the last device because that's usually a GPU or accelerator; device[0U] is usually the CPU
-    int64_t dev = deviceCount - 1;
-    if (getenv("FINDAFACTOR_OCL_DEFAULT_DEVICE")) {
-        dev = std::stoi(std::string(getenv("FINDAFACTOR_OCL_DEFAULT_DEVICE")));
-        if ((dev < 0) || (dev > (deviceCount - 1))) {
-            std::cout << "WARNING: Invalid FINDAFACTOR_OCL_DEFAULT_DEVICE selection. (Falling back to highest index device "
-                         "as default.)"
-                      << std::endl;
-            dev = deviceCount - 1;
-        }
-    }
-
-    // create the programs that we want to execute on the devices
-    int64_t plat_id = -1;
-    std::vector<cl::Context> all_contexts;
-    std::vector<std::string> all_filenames;
-    for (int64_t i = 0; i < deviceCount; ++i) {
-        // a context is like a "runtime link" to the device and platform;
-        // i.e. communication is possible
-        if (device_platform_id[i] != plat_id) {
-            plat_id = device_platform_id[i];
-            all_contexts.push_back(cl::Context(all_platforms_devices[plat_id]));
-        }
-        const std::string devName(all_devices[i].getInfo<CL_DEVICE_NAME>());
-        const bool useHostRam = all_devices_is_cpu[i] || (devName.find("Intel(R) UHD") != std::string::npos) ||
-            (devName.find("Iris") != std::string::npos);
-        DeviceContextPtr devCntxt =
-            std::make_shared<OCLDeviceContext>(devPlatVec[i], all_devices[i], all_contexts[all_contexts.size() - 1U], i,
-                plat_id, maxAllocVec[i % maxAllocVec.size()], all_devices_is_gpu[i], all_devices_is_cpu[i], useHostRam);
-
-        std::cout << "Device #" << i << ", ";
-        cl::Program program = MakeProgram(bitPow, devCntxt);
-
-        cl_int buildError =
-            program.build({ all_devices[i] }, "-cl-strict-aliasing -cl-denorms-are-zero -cl-fast-relaxed-math");
-        if (buildError != CL_SUCCESS) {
-            std::cout << "Error building for device #" << i << ": " << buildError << ", "
-                      << program.getBuildInfo<CL_PROGRAM_BUILD_STATUS>(all_devices[i])
-                      << program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(all_devices[i]) << std::endl;
-
-            // The default device was set above to be the last device in the list. If we can't compile for it, we
-            // use the first device. If the default is the first device, and we can't compile for it, then we don't
-            // have any devices that can compile at all, and the environment needs to be fixed by the user.
-            if (i == dev) {
-                default_dev_context = all_dev_contexts[0U];
-                default_platform = all_platforms[0U];
-                default_device = all_devices[0U];
-            }
-
-            continue;
-        }
-
-        all_dev_contexts.push_back(devCntxt);
-
-        for (unsigned int j = 0U; j < kernelHandles.size(); ++j) {
-            all_dev_contexts[i]->calls[kernelHandles[j].oclapi] =
-                cl::Kernel(program, kernelHandles[j].kernelname.c_str());
-            all_dev_contexts[i]->mutexes.emplace(kernelHandles[j].oclapi, new std::mutex);
-        }
-
-        if (i == dev) {
-            default_dev_context = all_dev_contexts[i];
-            default_platform = all_platforms[plat_id];
-            default_device = all_devices[i];
-        }
-    }
-
-    // For VirtualCL support, the device info can only be accessed AFTER all contexts are created.
-    std::cout << "Default platform: " << default_platform.getInfo<CL_PLATFORM_NAME>() << "\n";
-    std::cout << "Default device: #" << dev << ", " << default_device.getInfo<CL_DEVICE_NAME>() << "\n";
-    for (int64_t i = 0; i < deviceCount; ++i) {
-        std::cout << "OpenCL device #" << i << ": " << all_devices[i].getInfo<CL_DEVICE_NAME>() << "\n";
-    }
-
-    return InitOClResult(all_dev_contexts, default_dev_context);
-}
-
-OCLEngine::OCLEngine(const size_t bitPow)
-    : maxActiveAllocSizes(1U, -1)
-{
-    InitOClResult initResult = InitOCL(bitPow, maxActiveAllocSizes);
-    SetDeviceContextPtrVector(initResult.all_dev_contexts, initResult.default_dev_context);
-    activeAllocSizes = std::vector<size_t>(initResult.all_dev_contexts.size());
-}
-
-} // namespace Qrack