primes-utils 3.1.0 → 3.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d80c687d9af99e83fa89aa6d04b0d5b9f818568f46efb1d80ff31ee5959e348
-  data.tar.gz: 5cad72faacddd4ec9ed53c712dfecc337728fea989eaf87d9a42732e7e6b2c02
+  metadata.gz: 3435da9b5d2751b38cfcd941c71b3964f6720d49d6135e107a6d510c94d1a300
+  data.tar.gz: 643aaddc60f88c661a5df46a157694dc09ccb1985d0934850b4cee10aec96315
 SHA512:
-  metadata.gz: e1af46320695654351eca38beeb8efa42b1c08a93399526155e6f6d120945bbcd0af35dcdec176c0f4a686132e073258beaa25b803ed0a486442fdbf32a784ad
-  data.tar.gz: 2c2eff694192f3e007c788dd3788a6badce5920fd3539a6f0104e86b9b3f7333a93bb90444027817cb5b45a63062f592f4be361a25683325501f67e2d8a93313
+  metadata.gz: 1ba81561472f6b2f0aca9fa13e64f7ebd646cb9dc87c967f6eac8c7d2abe201b65a5bf9ee8b4356e66112a71b3f88568f0182f7d2ec25ffc31419eeabc78688f
+  data.tar.gz: c124bddc0251d7362b01b62a1e64f4caee2e6b0c0bca837a1a472cdf0eb743592786d6af017dd3b07f1eec840bccbe8f5244e929653a1d7662df243f77dfc841

data/README.md

@@ -34,28 +34,6 @@ Then require as:
 
 ## Methods
 
-**prime?**
-
-Determine if an integer value is prime, and return `true` or `false`.  
-This replaces the `prime?` method  in the `prime.rb` standard library.  
-Uses PGT residues tests, then Miller-Rabin test using `primemr?`.
-
-```
-101.prime? => true
-100.prime? => false
--71.prime? => false
-0.prime? => false
-1.prime? => false
-```
-
-**primemr?(k=5)**
-
-Optimized deterministic (over 64-bits) implementation of Miller-Rabin algorithm.      
-Default non-deterministic reliability set at k = 5, set higher if desired for very large numbers > 64-bts.
-
-```
-n.prime?(6)
-```
 
 **factors or prime_division**
 
@@ -80,7 +58,32 @@ Pure Ruby version equivalent of `factors`.
 Not as fast as `factors` for some values with multiple large prime factors.  
 Always available if OS doesn't have coreutils `factor`.
 
-**primes(start=0), primesmr(start=0)**
+```
+123_456_789.factors1 => [[3, 1], [7, 2], [839087, 1]]
+5_000_000_000_000_000_003.factors1 => [[5000000000000000003, 1]]
+987_654_321_012_345_678_901_382_739.factors1 => [[3, 1], [23, 1], [139, 1], [421, 1], [3469, 1], [7393, 1], [135899, 1], [70180703, 1]]
+```
+
+**prime?(k=5) or primemr?(k=5)**
+
+Determine if an integer value is prime, and return `true` or `false`.  
+`prime?` replaces the `prime?` method  in the `prime.rb` standard library.  
+It uses PGT residues tests, then Miller-Rabin test using `primemr?`.  
+Default probabilistic reliability constant set at k = 5, set higher if desired for numbers > 128-bts.  
+Not really necessary to do though.
+
+```
+101.prime? => true
+100.prime? => false
+-71.prime? => false
+0.primemr? => false
+1.primemr? => false
+5_000_000_000_000_000_003.primemr? => true
+987_654_321_012_345_678_901_382_737.prime? 6 => true
+987_654_321_012_345_678_901_382_739.prime? 6 => false
+```
+
+**primes(start=0) or primesmr(start=0)**
 
 Return an array of prime values within the inclusive integers range `[start_num - end_num]`.  
 Input order doesn't matter if both given: `start_num.primes end_num  <=> end_num.prime start_num`.  
@@ -103,13 +106,14 @@ prms => [1000003, 1000033, 1000037, 1000039, 1000081, 1000099]
 0.primesmr => []
 ```
 
-**primescnt(start=0), primescntmr(start=0)**
+**primescnt(start=0) or primescntmr(start=0)**
 
 Provide count of primes within the inclusive integers range `[start_num - end_num]`.  
 Input order doesn't matter if both given: `start_num.primes end_num  <=> end_num.prime start_num`.  
 A single input is taken as `end_num`, and the primes count <= to it are returned.  
-`primescnt` is faster; uses SoZ to identify|count primes from closest hashed value starting point.  
-`primescntmr` is slower, but isn't memory limited, especially for very large numbers|ranges.  
+`primescnt` is generally faster; uses SoZ to identify|count primes from closest hashed value starting point.  
+`primescntmr` is situationally slower, but isn't memory limited, especially for very large numbers|ranges.  
+Can also perform effective primality test on an integer n as: `n.primescntmr n`  
 See `PRIMES-UTILS HANDBOOK` for details on best use practices.
 Also see `Error Handling`.
 
@@ -120,8 +124,11 @@ Also see `Error Handling`.
 100000.primescntmr 100500 => 40
 n=10**400; (n-500).primescntmr(n+500) => 1
 n=10**8; (25*n).primescnt => 121443371
+541.primescntmr 7919 => 901
 0.primescnt   => 0
 1.primescntmr => 0
+100.primescntmr 100 => 0
+101.primescntmr 101 => 1
 ```
 
 **primenth(p=0) or nthprime(p=0)**
@@ -174,7 +181,7 @@ Return value of previous prime < n > 2. Returns `nil` for n < 2 (and negatives)
 Displays a list of all the `primes-utils` methods available for a system.  
 Use as eg: `0.primes_utils` where input n is any `class Integer` value.
 
-Available methods for 3.0.0.
+Available methods for 3.1.2.
 
 ```
 0.primes_utils => "prime? primes primesmr primescnt primescntmr primenth|nthprime factors|prime_division factors1 next_prime prev_prime primes_utils"
@@ -194,9 +201,9 @@ If they occur you will know why now.
 This behavior is referenced to MRI Ruby.
 
 ## Coding Implementations
-The method `prime_division|factors` has 2 implementations. A pure ruby implementation, and a hybrid implementation 
+The method `prime_division|factors` has 2 implementations. A pure ruby implementation `factors1`, and a hybrid implementation 
 using the Unix cli command `factor` [5], if available on the host OS. It's an extremely fast C coded factoring algorithm, 
-part of the GNU Core Utilities package [4].
+part of the GNU Core Utilities package [4]. However, `factors1` is always exists separately.
 
 Upon loading, the gem tests if the command `factor` exists on the host OS.
 If so, it performs a system call to it within `prime_division|factors`, and Ruby reformats its output.
@@ -208,6 +215,8 @@ All the `primes-utils` methods are `instance_methods` for `Class Integer`.
 
 ## History
 ```
+3.1.2 – method refactor, documentation updates
+3.1.1 – some methods refactoring|DRYing, documentation updates
 3.1.0 – major performance enhancements for methods primescnt, primescntmr, and nthprimes,
         primarily by extending nth primes hash values up to 10.1 billion. Can now find nth primes
         over ranges up to 10.1 billion, and thus prime counts up to 253+ billion, in < 30 secs at ~5Ghz.

data/lib/primes/utils/version.rb

@@ -1,5 +1,5 @@
 module Primes
   module Utils
-    VERSION = "3.1.0"
+    VERSION = "3.1.2"
   end
 end

data/lib/primes/utils.rb

@@ -112,7 +112,7 @@ module Primes
     def primescnt(start_num = 0)
       end_num, start_num = check_inputs(self, start_num)
 
-      nthflag, nth = 0, 0
+      nthflag, nth = nil, 0
       if start_num < 3                 # for all primes upto num
         start_num, nth, nthflag = set_start_value(end_num, false) # closest nth value
         return nth unless nthflag      # output num's key|count if ref nth value
@@ -149,7 +149,7 @@ module Primes
     def primescntmr(start_num = 0)
       end_num, start_num = check_inputs(self, start_num)
 
-      nthflag, nth = 0, 0
+      nthflag, nth = nil, 0
       if start_num < 3                 # for all primes upto num
         start_num, nth, nthflag = set_start_value(end_num, false) # closest nth value
         return nth unless nthflag      # output num's key|count if ref nth value
@@ -167,7 +167,7 @@ module Primes
     end
 
     # PGT and Miller-Rabin combined primality tests for random n
-    def prime? (k = 5)       # Can change k up|down for primemr?
+    def prime?(k = 5)        # Can change k up|down for primemr?
       # Use PGT residue checks for small values < PRIMES.last**2
       return PRIMES.include? self if self <= PRIMES.last
       return false if MODPN.gcd(self) != 1
@@ -247,7 +247,7 @@ module Primes
     PRIMES = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103]
     PRIMES_LAST_SQRD = PRIMES.last ** 2
 
-    # Retunr correct order for inputs range values start_num|end_num
+    # Return correct order for inputs range values start_num|end_num
     # If either are negative then raise an error
     def check_inputs(end_num, start_num)
       raise "invalid negative input(s)" if end_num < 0 || start_num < 0
@@ -255,7 +255,7 @@ module Primes
       [end_num, start_num]
     end
 
-    # Returns for SP PG mod value array of residues [r1, r2,..mod-1, mod+1]
+    # Returns for SP PG mod value array of residues [r0, r1,..mod-1, mod+1]
     def make_residues(modpg)
       return [ 7, 11, 13, 17, 19, 23, 29, 31] if modpg == 30
       return [11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
@@ -263,24 +263,14 @@ module Primes
              139, 143, 149, 151, 157, 163, 167, 169, 173, 179, 181, 187, 191,
              193, 197, 199, 209, 211] if modpg == 210
       residues = []
-      pc, inc, midmod = 13, 4, modpg >> 1
-      while pc < midmod
-        residues << pc << (modpg - pc) if modpg.gcd(pc) == 1
-        pc += inc; inc ^= 0b110
+      rc, inc, midmod = 13, 4, modpg / 2
+      while rc < midmod
+        residues << rc << (modpg - rc) if modpg.gcd(rc) == 1
+        rc += inc; inc ^= 0b110
       end
       residues.sort << (modpg - 1) << (modpg + 1)
     end
 
-    # lte =  true: first output element is number of pcs <= num
-    # lte = false: num pcs <, residue index, resgroup val, for (start_)num pc
-    def pcs_to_num(num, residues, lte)
-      modpg, rescnt = residues[-1] - 1, residues.size
-      num -= 1; lte ? (num |= 1; k = num.abs/modpg) : k = (num - 1).abs/modpg
-      modk = modpg * k; r = 0
-      r = r.succ while num >= modk + residues[r]
-      [rescnt * k + r, r, modk]                # [num pcs, r index, num modulus]
-    end
-
     # Determine number of pcs upto the effective start, end, and range width.
     # The effective start_num is first pc >= start_num, first pc <= end_num,
     # and effective range is number of pcs between them (inclusive).
@@ -292,15 +282,13 @@ module Primes
     #          pcs_in_range - total number of pcs in effective range
     def pcs_to_nums(end_num, start_num, residues)
       modpg, rescnt = residues[-1] - 1, residues.size
-      end_num   = 2 if end_num   < residues[0]
-      start_num = 2 if start_num < residues[0]
-      start_num -= 1; k1 = (start_num - 1)/modpg; modk1 = modpg * k1
-      end_num   -= 1; k2 = (end_num |= 1 )/modpg; modk2 = modpg * k2
-      r1 = 0; r1 = r1.succ while start_num >= modk1 + residues[r1]
-      r2 = 0; r2 = r2.succ while end_num   >= modk2 + residues[r2]
-      pcs_to_end = k2 * rescnt + r2; pcs_to_start = k1 * rescnt + r1
-      pcs_in_range = pcs_to_end - pcs_to_start
-      [pcs_to_end, pcs_to_start, r1, modk1, pcs_in_range]
+      end_num,   k2 = end_num   < residues[0] ? [1, 0] : [(end_num - 1)|1, ((end_num - 1)|1)/modpg]
+      start_num, k1 = start_num < residues[0] ? [1, 0] : [start_num - 1,   (start_num - 2)/modpg]
+      r1, r2, resk1, resk2  = 0, 0, start_num - (modk1 = k1 * modpg), end_num - (k2 * modpg)
+      r1 = r1.succ while resk1 >= residues[r1]
+      r2 = r2.succ while resk2 >= residues[r2]
+      pcs_to_end, pcs_to_start = k2 * rescnt + r2, k1 * rescnt + r1
+      [pcs_to_end, pcs_to_start, r1, modk1, (pcs_in_range = pcs_to_end - pcs_to_start)]
     end
 
     # Select SP Prime Generator to parametize the pcs within inputs range
@@ -316,11 +304,11 @@ module Primes
               elsif range < 24_494_897;   510_510  # P17; Math.isqrt(600_000_000_000_000)
               else                      9_699_690  # P19
               end
-      residues = make_residues(modpg)       # chosen PG residues
+      residues = make_residues(modpg)              # chosen PG residues
       primes = PRIMES.select { |p| p < residues[0] && p.between?(start_num, end_num) }
-      start_num = 2 if start_num < residues[0]
-      k = (start_num - 2) / modpg; modk = k * modpg; r = 0
-      while (start_num - 1) >= modk + residues[r]; r = r.succ end
+      start_num = start_num < residues[0] ? 1 : start_num - 1
+      k = (start_num - 1) / modpg; modk = k * modpg; r = 0; resk = start_num - modk
+      r = r.succ while resk >= residues[r]
       [r, modk, residues, primes]
     end
 
@@ -334,8 +322,8 @@ module Primes
     #          rs       - residue index location for first pc >= start_num
     def sozcore2(end_num, start_num, modpg)
       residues = make_residues(modpg); rescnt = residues.size
-      maxpcs, pcs_to_start, rs, modks, pcs_range = pcs_to_nums(end_num, start_num, residues)
-      sqrtN, inputs_range = Integer.sqrt(end_num), end_num - start_num
+      pcs_to_end, pcs_to_start, rs, modks, pcs_range = pcs_to_nums(end_num, start_num, residues)
+      sqrtN, maxpcs, inputs_range = Integer.sqrt(end_num), pcs_to_end, end_num - start_num
       pcs_to_sqrtN, _ = pcs_to_nums(sqrtN, 0, residues) # num pcs <= sqrtN
 
       m = pcs_to_start                      # index to start retrieving primes in prms array
@@ -355,7 +343,7 @@ module Primes
         prm_r = residues[i % rescnt]        # save its residue value
         prime = modpg*(k=i/rescnt) + prm_r  # numerate its value; set k resgroup value
         rem   = start_num % prime           # prime's modular distance to start_num
-        next unless (prime - rem <= inputs_range) || rem == 0 # skip prime if no mulitple in range
+        next unless (prime - rem <= inputs_range) || rem == 0 # skip prime if no multiple in range
         prmstep = prime * rescnt            # compute its primestep
         residues.each do |ri|               # find|mark its multiples
           # convert (prime * (modk + ri)) pc value to its address in prms

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: primes-utils
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.1.2
 platform: ruby
 authors:
 - Jabari Zakiya
@@ -92,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: suite of extremely fast utility methods for testing and generating primes
 test_files: []