Option to skip trial division

Author: WrathfulSpatula

FindAFactor/_find_a_factor.cpp

@@ -1008,7 +1008,8 @@ struct Factorizer {
 };
 
 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, size_t batchSizeVariance, size_t ladderMultiple) {
+                          size_t wheelFactorizationLevel, double smoothnessBoundMultiplier, double batchSizeMultiplier, size_t batchSizeVariance, size_t ladderMultiple,
+                          bool skipTrialDivision) {
   // Validation section
   if (method > 1U) {
     std::cout << "Mode number " << method << " not implemented. Defaulting to FACTOR_FINDER." << std::endl;
@@ -1048,26 +1049,28 @@ std::string find_a_factor(std::string toFactorStr, size_t method, size_t nodeCou
   const auto itg = std::upper_bound(primes.begin(), primes.end(), gearFactorizationLevel);
   const size_t wgDiff = std::distance(itw, itg);
 
-  // This is simply trial division up to the ceiling.
-  std::mutex trialDivisionMutex;
-  for (size_t primeIndex = 0U; (primeIndex < primes.size()) && (result == 1U); primeIndex += 64U) {
-    dispatch.dispatch([&toFactor, &primes, &result, &trialDivisionMutex, primeIndex]() -> bool {
-      const size_t maxLcv = std::min(primeIndex + 64U, primes.size());
-      for (size_t pi = primeIndex; pi < maxLcv; ++pi) {
-        const size_t& currentPrime = primes[pi];
-        if (!(toFactor % currentPrime)) {
-          std::lock_guard<std::mutex> lock(trialDivisionMutex);
-          result = currentPrime;
-          return true;
+  if (!skipTrialDivision) {
+    // This is simply trial division up to the ceiling.
+    std::mutex trialDivisionMutex;
+    for (size_t primeIndex = 0U; (primeIndex < primes.size()) && (result == 1U); primeIndex += 64U) {
+      dispatch.dispatch([&toFactor, &primes, &result, &trialDivisionMutex, primeIndex]() -> bool {
+        const size_t maxLcv = std::min(primeIndex + 64U, primes.size());
+        for (size_t pi = primeIndex; pi < maxLcv; ++pi) {
+          const size_t& currentPrime = primes[pi];
+          if (!(toFactor % currentPrime)) {
+            std::lock_guard<std::mutex> lock(trialDivisionMutex);
+            result = currentPrime;
+            return true;
+          }
         }
-      }
-      return false;
-    });
-  }
-  dispatch.finish();
-  // If we've checked all primes below the square root of toFactor, then it's prime.
-  if ((result != 1U) || (toFactor <= (primeCeiling * primeCeiling))) {
-    return boost::lexical_cast<std::string>(result);
+        return false;
+      });
+    }
+    dispatch.finish();
+    // If we've checked all primes below the square root of toFactor, then it's prime.
+    if ((result != 1U) || (toFactor <= (primeCeiling * primeCeiling))) {
+      return boost::lexical_cast<std::string>(result);
+    }
   }
 
   // Set up wheel factorization (or "gear" factorization)

FindAFactor/find_a_factor.py

@@ -19,7 +19,8 @@ def find_a_factor(n,
                   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 512.0,
                   batch_size_variance=int(os.environ.get('FINDAFACTOR_BATCH_SIZE_VARIANCE')) if os.environ.get('FINDAFACTOR_BATCH_SIZE_VARIANCE') else 2,
-                  ladder_multiple=int(os.environ.get('FINDAFACTOR_LADDER_MULTIPLE')) if os.environ.get('FINDAFACTOR_LADDER_MULTIPLE') else 6):
+                  ladder_multiple=int(os.environ.get('FINDAFACTOR_LADDER_MULTIPLE')) if os.environ.get('FINDAFACTOR_LADDER_MULTIPLE') else 6,
+                  skip_trial_division=True if os.environ.get('FINDAFACTOR_SKIP_TRIAL_DIVISION') else False):
     return int(_find_a_factor._find_a_factor(str(n),
                                              int(method),
                                              node_count, node_id,
@@ -29,4 +30,5 @@ def find_a_factor(n,
                                              smoothness_bound_multiplier,
                                              batch_size_multiplier,
                                              batch_size_variance,
-                                             ladder_multiple))
+                                             ladder_multiple,
+                                             skip_trial_division))

README.md

@@ -35,7 +35,8 @@ factor = find_a_factor(
     smoothness_bound_multiplier=1.0,
     batch_size_multiplier=512.0,
     batch_size_variance=2,
-    ladder_multiple=5
+    ladder_multiple=5,
+    skip_trial_division=False
 )
 ```
 
@@ -51,6 +52,7 @@ The `find_a_factor()` function should return any nontrivial factor of `to_factor
 - `batch_size_multiplier` (default value: `512.0`): For `FACTOR_FINDER`/`1` method, each `1.0` increment of the multiplier adds `k ln k` Markov mixing replacement steps for `k` count of smooth primes, before reseeding Monte Carlo.
 - `batch_size_variance` (default value: `2`): For `FACTOR_FINDER`/`1` method, `k ln k` is the right proportionality for a Markov mixing process, but a linear factor in front is hard to predict. As such, it can be useful to dynamically vary the batch size, as if to cover and amortize the cost of several different batch sizes at once. In sequence, each batch size will be multiplied by `2 ** i` for `i` in `range(batch_size_variance)`, repeating from `0`.
 - `ladder_multiple` (default value: `6`): Controls how many times randomly-selected square prime multiplication is repeated with the same square prime per random selection, in ascending a "ladder" of smooth perfect squares. A random number between `1` and `ladder_multiple` is selected for how many times the current smooth perfect square is multiplied each randomly selected square prime, while division still occurs 1 square prime multiple at a time. (Any smooth perfect square can be multiplied by any square prime in the factor base, or any other smooth perfect square, and produce a different smooth perfect square.)
+- `skip_trial_division` (default value: `False`): `False` performs initial-phase trial division, and `True` skips it. Note that `trial_division_level` still functions as the input to Sieve of Eratosthenes to collect a list of primes from which (`FACTOR_FINDER`) smooth primes can be selected. If `skip_trial_division=True`, simply set `trial_division_level` high enough to avoid truncation warnings, unless otherwise desired.
 
 All variables defaults can also be controlled by environment variables:
 - `FINDAFACTOR_METHOD` (integer value)

find_a_factor

@@ -20,10 +20,11 @@ def main():
     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 11
-    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 512.0
+    smoothness_bound_multiplier = float(os.environ.get('FINDAFACTOR_SMOOTHNESS_BOUND_MULTIPLIER')) if os.environ.get('FINDAFACTOR_SMOOTHNESS_BOUND_MULTIPLIER') else 2.0
+    batch_size_multiplier=float(os.environ.get('FINDAFACTOR_BATCH_SIZE_MULTIPLIER')) if os.environ.get('FINDAFACTOR_BATCH_SIZE_MULTIPLIER') else 256.0
     batch_size_variance=int(os.environ.get('FINDAFACTOR_BATCH_SIZE_VARIANCE')) if os.environ.get('FINDAFACTOR_BATCH_SIZE_VARIANCE') else 2
     ladder_multiple=int(os.environ.get('FINDAFACTOR_LADDER_MULTIPLE')) if os.environ.get('FINDAFACTOR_LADDER_MULTIPLE') else 6
+    skip_trial_division=True if os.environ.get('FINDAFACTOR_SKIP_TRIAL_DIVISION') else False
 
     if argv_len > 2:
         method = FactoringMethod(int(sys.argv[2]))
@@ -43,7 +44,9 @@ def main():
     if argv_len > 10:
         ladder_multiple = int(sys.argv[10])
     if argv_len > 11:
-        trial_division_level = int(sys.argv[11])
+        skip_trial_division = sys.argv[11] not in ['False', '0']
+    if argv_len > 12:
+        trial_division_level = int(sys.argv[12])
 
     start = time.perf_counter()
     result = find_a_factor(
@@ -57,7 +60,8 @@ def main():
         smoothness_bound_multiplier = smoothness_bound_multiplier,
         batch_size_multiplier = batch_size_multiplier,
         batch_size_variance = batch_size_variance,
-        ladder_multiple=ladder_multiple
+        ladder_multiple=ladder_multiple,
+        skip_trial_division=skip_trial_division
     )
     print(time.perf_counter() - start)
     print(str(result) + " * " + str(to_factor // result) + " == " + str(to_factor))

pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "FindAFactor"
-version = "4.7.11"
+version = "4.8.0"
 requires-python = ">=3.8"
 description = "Find any nontrivial factor of a number"
 readme = {file = "README.txt", content-type = "text/markdown"}

setup.py

@@ -40,7 +40,7 @@ def build_extension(self, ext):
 
 setup(
     name='FindAFactor',
-    version='4.7.11',
+    version='4.8.0',
     author='Dan Strano',
     author_email='stranoj@gmail.com',
     description='Find any nontrivial factor of a number',