primes-utils 3.1.1 → 3.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e4efbd1adfba3980cb7d23ff8d6a604c835a1d8159993d52676941534ac9454
-  data.tar.gz: 1e730c6ec9e6e505cc7dbcaa706c7a788f25fd3b746b8d3738002f2c95d2d8bd
+  metadata.gz: 3435da9b5d2751b38cfcd941c71b3964f6720d49d6135e107a6d510c94d1a300
+  data.tar.gz: 643aaddc60f88c661a5df46a157694dc09ccb1985d0934850b4cee10aec96315
 SHA512:
-  metadata.gz: 6af6def197418a3c5cf68c0a75d0ce182a96b60f1f414d6da2762ddf7156476a0d863f79bc65d08dc6824d62421f932e082ffb0b718f632a19ac416af618292a
-  data.tar.gz: 954aa75ea469ef4ccaaaf3b14b20c78d4d2c1b7e2ee7803126d40e2d35fbcd68e9682bf30710ca7127af31b2f86688951970bef2f7e51ac8ff3102973d0ca984
+  metadata.gz: 1ba81561472f6b2f0aca9fa13e64f7ebd646cb9dc87c967f6eac8c7d2abe201b65a5bf9ee8b4356e66112a71b3f88568f0182f7d2ec25ffc31419eeabc78688f
+  data.tar.gz: c124bddc0251d7362b01b62a1e64f4caee2e6b0c0bca837a1a472cdf0eb743592786d6af017dd3b07f1eec840bccbe8f5244e929653a1d7662df243f77dfc841

data/README.md

@@ -34,32 +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 (to 128-bits) implementation of Miller-Rabin algorithm.  
-It's the underlying primality test for `prime`, and used in other methods.  
-Default probabilistic reliability constant set at k = 5, set higher if desired for numbers > 128-bts.  
-Not really necessary to do though.
-
-```
-5_000_000_000_000_000_003.primemr? => true
-987_654_321_012_345_678_901_382_737.primemr? 6 => true
-987_654_321_012_345_678_901_382_739.primemr? 6 => false
-```
 
 **factors or prime_division**
 
@@ -90,7 +64,26 @@ Always available if OS doesn't have coreutils `factor`.
 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]]
 ```
 
-**primes(start=0), primesmr(start=0)**
+**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`.  
@@ -113,7 +106,7 @@ 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`.  
@@ -188,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.1.1.
+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"
@@ -222,6 +215,7 @@ 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

data/lib/primes/utils/version.rb

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

data/lib/primes/utils.rb

@@ -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
@@ -271,20 +271,24 @@ module Primes
       residues.sort << (modpg - 1) << (modpg + 1)
     end
 
-    # Determine number of pcs upto the effective start|end vals; w/flag
+    # 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).
-    # inputs:  end_num|start_num of range, PGs residues array, start:t|end:f flag
-    # outputs: pcs_to_num   - number of pcs < start_num or <= end_num
-    #          r            - residue index for effective start_num pc
-    #          modk         - mod resgroup value for effective num value
-    def pcs_to_num(num, residues, flag)
-      return [0, 0, 0] if num < residues[0]
+    # inputs:  end_num and start_num of range, and PGs residues array
+    # outputs: pcs_to_end   - number of pcs in <= end_num pc for PG
+    #          pcs_to_start - number of pcs < effective start_num pc for range
+    #          r1           - residue index for effective start_num pc
+    #          modk1        - mod resgroup value for effective start_num pc
+    #          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
-      val1, val2  = flag ? [num-2, num-1] : [(num-1)|1, (num-1)|1]
-      k = val1 / modpg; modk = k * modpg; r = 0; resk = val2 - modk
-      r = r.succ while resk >= residues[r]; pcs_to_num = k * rescnt + r
-      [pcs_to_num, r, modk]
+      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
@@ -300,9 +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) }
-      _, r, modk = pcs_to_num(start_num, residues, true)
+      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
 
@@ -315,12 +321,10 @@ module Primes
     #          pcs2start- number of pcs < start_num pc
     #          rs       - residue index location for first pc >= start_num
     def sozcore2(end_num, start_num, modpg)
-      residues = make_residues(modpg)
-      rescnt, sqrtN = residues.size, Integer.sqrt(end_num)
-      pcs_to_start, rs, modks = pcs_to_num(start_num, residues, true) # num pcs <  start_num
-      maxpcs, _               = pcs_to_num(end_num, residues, false)  # num pcs <= end_num
-      pcs_to_sqrtN, _         = pcs_to_num(sqrtN, residues, false)    # num pcs <= sqrtN
-      inputs_range, pcs_range = end_num - start_num, maxpcs - pcs_to_start
+      residues = make_residues(modpg); rescnt = residues.size
+      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
       split_arrays = (start_num > sqrtN)    # flag, true for split arrays

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: primes-utils
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.1.2
 platform: ruby
 authors:
 - Jabari Zakiya