primes-utils 3.1.0 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d80c687d9af99e83fa89aa6d04b0d5b9f818568f46efb1d80ff31ee5959e348
-  data.tar.gz: 5cad72faacddd4ec9ed53c712dfecc337728fea989eaf87d9a42732e7e6b2c02
+  metadata.gz: 6e4efbd1adfba3980cb7d23ff8d6a604c835a1d8159993d52676941534ac9454
+  data.tar.gz: 1e730c6ec9e6e505cc7dbcaa706c7a788f25fd3b746b8d3738002f2c95d2d8bd
 SHA512:
-  metadata.gz: e1af46320695654351eca38beeb8efa42b1c08a93399526155e6f6d120945bbcd0af35dcdec176c0f4a686132e073258beaa25b803ed0a486442fdbf32a784ad
-  data.tar.gz: 2c2eff694192f3e007c788dd3788a6badce5920fd3539a6f0104e86b9b3f7333a93bb90444027817cb5b45a63062f592f4be361a25683325501f67e2d8a93313
+  metadata.gz: 6af6def197418a3c5cf68c0a75d0ce182a96b60f1f414d6da2762ddf7156476a0d863f79bc65d08dc6824d62421f932e082ffb0b718f632a19ac416af618292a
+  data.tar.gz: 954aa75ea469ef4ccaaaf3b14b20c78d4d2c1b7e2ee7803126d40e2d35fbcd68e9682bf30710ca7127af31b2f86688951970bef2f7e51ac8ff3102973d0ca984

data/README.md

@@ -50,11 +50,15 @@ Uses PGT residues tests, then Miller-Rabin test using `primemr?`.
 
 **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.
+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.
 
 ```
-n.prime?(6)
+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**
@@ -80,6 +84,12 @@ 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`.
 
+```
+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]]
+```
+
 **primes(start=0), primesmr(start=0)**
 
 Return an array of prime values within the inclusive integers range `[start_num - end_num]`.  
@@ -108,8 +118,9 @@ prms => [1000003, 1000033, 1000037, 1000039, 1000081, 1000099]
 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 +131,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 +188,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.1.
 
 ```
 0.primes_utils => "prime? primes primesmr primescnt primescntmr primenth|nthprime factors|prime_division factors1 next_prime prev_prime primes_utils"
@@ -194,9 +208,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 +222,7 @@ All the `primes-utils` methods are `instance_methods` for `Class Integer`.
 
 ## History
 ```
+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.1"
   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
@@ -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,44 +263,28 @@ 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.
+    # Determine number of pcs upto the effective start|end vals; w/flag
     # 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 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)
+    # 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]
       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]
+      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
 
     # Select SP Prime Generator to parametize the pcs within inputs range
@@ -318,9 +302,7 @@ module Primes
               end
       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
+      _, r, modk = pcs_to_num(start_num, residues, true)
       [r, modk, residues, primes]
     end
 
@@ -333,10 +315,12 @@ 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 = 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_sqrtN, _ = pcs_to_nums(sqrtN, 0, residues) # num pcs <= sqrtN
+      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
 
       m = pcs_to_start                      # index to start retrieving primes in prms array
       split_arrays = (start_num > sqrtN)    # flag, true for split arrays
@@ -355,7 +339,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.1
 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: []