primes-utils 1.1.1 → 2.0.0

data/.gitignore

@@ -7,3 +7,8 @@
 /pkg/
 /spec/reports/
 /tmp/
+*.gem
+.directory
+*.odt
+*.odt#
+*.pdf

data/README.md

@@ -1,6 +1,16 @@
 # primes-utils
 
-primes-utils is a Rubygem which provides a suite of extremely fast (relative to Ruby's standard library) utility methods for testing and generating primes.
+## Introduction
+
+`primes-utils` is a Rubygem which provides a suite of extremely fast (relative to Ruby's standard library) utility methods for testing and generating primes.
+
+For details on best use practices and implementation details see:
+
+`PRIMES-UTILS HANDBOOK`
+
+https://www.scribd.com/doc/266461408/Primes-Utils-Handbook
+
+Periodically check for updates.
 
 ## Installation
 
@@ -39,10 +49,9 @@ This replaces the `prime?` method  in the `prime.rb` standard library.
 
 **primemr?(k=20)**
 
-Determine if the absolute value of an integer is prime using Miller-Rabin test.  Return 'true' or 'false'.
-Miller-Rabin here is super fast, but probabilistic (not deterministic), primality test.
-https://en.wikipedia.org/wiki/Miller-Rabin_primality_test
-The method's reliability can be increased by increasing the default input parameter of k=20.
+Using Miller-Rabin primality test for integers, return 'true' or 'false'.
+Miller-Rabin [6] is super fast, but probabilistic (not deterministic), primality test.
+The reliability can be increased by increasing the default input parameter of k=20.
 
 ```
 1111111111111111111.primemr? => true
@@ -58,7 +67,7 @@ The method's reliability can be increased by increasing the default input parame
 
 Determine the prime factorization of the absolute value of an integer.
 This replaces the `prime division` method in the `prime.rb` standard library.
-Returns an array of arrays of factors and exponents: [[2,4],[3,2],[5,1]] => (2^4)(3^2)(5^1) = (16)(9)(5) = 720
+Output is array of arrays of factors and exponents: [[p1,e1],[p2,e2]..[pn,en]]
 Default Strictly Prime (SP) Prime Generator (PG) used here is P13.
 Can change SP PG used on input. Acceptable primes range: [3 - 19].
 
@@ -73,50 +82,83 @@ Can change SP PG used on input. Acceptable primes range: [3 - 19].
 1.factors => []
 ```
 
-**primes(start=0)**
+**primes(start=0), primesf(start=0), primesmr(start=0)**
 
-Create an array of primes from the absolute value range (|start| - |end|).
-The order of the range doesn't matter if both given: start.primes end  <=> end.prime start
+Return an array of primes within the absolute value range `(|start| - |end|)`.
+The order of the range doesn't matter if both given: `start.primes end  <=> end.prime start`
 If only one parameter used, then all the primes upto that number will be returned.
+See `PRIMES-UTILS HANDBOOK` for details on best use practices.
 
 ```
 50.primes => [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
-50.primes 125 => [53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113]
+50.primesf 125 => [53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113]
 300.primes 250 => [251, 257, 263, 269, 271, 277, 281, 283, 293]
+n=10**100; (n-250).primesmr(n+250) => []
 541.primes.size => 100
 1000.primes(5000).size => 501
 (prms = 1000000.primes(1000100)).size => 6
 prms.size => 6
 prms => [1000003, 1000033, 1000037, 1000039, 1000081, 1000099]
 -10.primes -50  => [11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
-0.primes => []
-1.primes => []
+0.primesf  => []
+1.primesmr => []
 ```
 
-**primenth(p=11) or nthprime(p=11)**
+**primescnt(start=0), primescntf(start=0), primescntmr(start=0)**
 
-Return the value of the nth (absolute value) prime.
-Default Strictly Prime (SP) Prime Generator (PG) used here is P11.
-Can change SP PG used on input. Acceptable primes range: [3 - 19].
+Provide count of primes within the absolute value range `(|start| - |end|)`.
+The order of the range doesn't matter if both given: `start.primes end  <=> end.prime start`
+If only one parameter used, the count of all the primes upto that number will be returned.
+See `PRIMES-UTILS HANDBOOK` for details on best use practices.
+
+```
+100000.primescnt => 9592
+100000.primescntf 100500 => 40
+n=10**400; (n-500).primescntmr(n+500) => 1
+-10.primescnt -50  => 11
+0.primescntf  => 0
+1.primescntmr => 0
+```
+
+**primenth(p=7) or nthprime(p=7)**
+
+Return the value of the (absolute value of) nth prime.
+Default Strictly Prime (SP) Prime Generator (PG) used here is P7.
+Can change SP PG used on input. Acceptable primes range: [3 - 13].
+Currently, parameters are set so that the 1122951705th prime is max.
+An error message will be given if requested nth prime is > than max.
 
 ```
 1000000.primenth => 15485863
 1500000.nthprime => 23879519
-2000000.nthprime 13 => 32452843
+2000000.nthprime 11 => 32452843
 -500000.nthprime => 7368787
+1122951705.nthprime => 25741879847
+1122951706.primenth => "1122951705 not enough primes, nth approx too small"
 0.nthprime => 0
 ```
 
-## Coding Implementations
-The methods `primemr`, `nthprime/primenth`, and `primes` are coded in pure ruby.
-The methods `prime?` and `prime_division/factors` have two implementations.
-Each has a pure ruby implementation, and also a hybrid implementation which uses the
-Unix cli command `factor` if its available on the host OS. `factor` [5] is an extremely fast
-C coded factoring algorithm, part of the GNU Core Utilities package [4].
+**primes_utils**
 
-Upon loading, the gem tests if the desired `factor` command exists on the host OS.
-If so, it wraps a system call to it and uses it for `prime?` and `prime_division/factors`. 
-If not, it uses a fast pure ruby implementation for each method based on the Sieve of Zakiya (SoZ)[1][2][3].
+Displays a list of all the `primes-utils` methods available for your system. 
+Use as `x.primes_utils` where x is any `class Integer` value.
+
+```
+0.primes_utils => "prime? primemr? primes primesf primesmr primescnt primescntf primescntmr primenth|nthprime factors|prime_division"
+```
+
+## Coding Implementations
+The methods `primemr?`, `nthprime/primenth`, `primes`, `primescnt`, `primesmr`, and `primescnt` are coded in pure ruby.
+The methods `prime?` and `prime_division|factors` have two implementations.
+Each has a pure ruby implementation, and a hybrid implementation using the Unix cli command `factor` if its available on the host OS. 
+The methods `primesf` and `primescntf` use the `factor` version of `prime?` and are created if it exits.
+`factor` [5] is an extremely fast C coded factoring algorithm, part of the GNU Core Utilities package [4].
+ 
+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?` and `prime_division/factors`, which uses its output. 
+If not, each method uses a fast pure ruby implementation based on the Sieve of Zakiya (SoZ)[1][2][3].
+
+All the `primes-utils` methods are `instance_methods` for `class Integer`.
 
 ## Author
 Jabari Zakiya
@@ -124,9 +166,11 @@ Jabari Zakiya
 ## References
 [1]https://www.scribd.com/doc/150217723/Improved-Primality-Testing-and-Factorization-in-Ruby-revised
 [2]https://www.scribd.com/doc/228155369/The-Segmented-Sieve-of-Zakiya-SSoZ
-[3]https://www.scribd.com/doc/73385696/The-Sieve-of-Zakiya  
-[4]https://en.wikipedia.org/wiki/GNU_Core_Utilities  
+[3]https://www.scribd.com/doc/73385696/The-Sieve-of-Zakiya
+[4]https://en.wikipedia.org/wiki/GNU_Core_Utilities
 [5]https://en.wikipedia.org/wiki/Factor_(Unix)
+[6]https://en.wikipedia.org/wiki/Miller-Rabin_primality_test
+
 
 ## License
-GPL 2.0 or later.
+GPLv2+

data/lib/primes/utils.rb

@@ -1,8 +1,9 @@
 require "primes/utils/version"
-require 'rational' if RUBY_VERSION =~ /^(1.8)/   # for 'gcd' method
+require "rational" if RUBY_VERSION =~ /^(1.8)/   # for 'gcd' method
 
 module Primes
   module Utils
+    # Upon loading, determine if platform has cli command 'factor'
     private
     os_has_factor = false
     begin
@@ -13,6 +14,11 @@ module Primes
       os_has_factor = false
     end
 
+    # Methods primes* and primescnt* use a number range: end_num - start_num
+    # Use as: end_num.primes*(start_num) (or vice versa) or end_num.primes
+    # If start_num omitted, the method will find all primes <= end_num
+    # If start_num > self, values are switched to make end_num > start_num
+
     public
     if os_has_factor   # for platforms with cli 'factor' command
 
@@ -25,15 +31,43 @@ module Primes
         h = Hash.new(0); factors.each {|f| h[f] +=1}; h.to_a.sort
       end
 
-      puts "Using cli 'factor' for prime?/factors/prime_division"
+      def primesf(start_num=0)
+        # Find primes within a number range: end_num - start_num
+        # Uses 'prime?' to check primality of prime candidates in range
+        sozdata = sozcore1(self, start_num, true) # true for primes
+        return sozdata[1] if sozdata[0]
+        pcs_in_range, r, mod, modk, rescnt, residues, primes = sozdata[1..-1]
+        pcs_in_range.times do         # find primes from this num pcs in range
+          prime = modk + residues[r]
+	  primes << prime if prime.prime?
+	  r +=1; if r > rescnt; r=1; modk +=mod end
+        end
+        primes
+      end
+
+      def primescntf(start_num=0)
+        # Count primes within a number range: end_num - start_num
+        # Uses 'prime?' to check primality of prime candidates in range
+        sozdata = sozcore1(self, start_num, false) # false for primescnt
+        return sozdata[1] if sozdata[0]
+        pcs_in_range, r, mod, modk, rescnt, residues, primes = sozdata[1..-1]
+        primescnt = primes.size
+        pcs_in_range.times do         # count primes from this num pcs in range
+	  primescnt +=1 if (modk + residues[r]).prime?
+	  r +=1; if r > rescnt; r=1; modk +=mod end
+        end
+        primescnt
+      end
+
+      puts "Using cli 'factor' for prime? primesf  primescntf  factors|prime_division"
 
     else  # use pure ruby versions for platforms without cli command 'factor'
 
-      def prime?
-        residues = [1,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,
-          89,97,101,103,107,109,113,121,127,131,137,139,143,149,151,157,163,
-          167,169,173,179,181,187,191,193,197,199,209,211]
-        mod=210; rescnt=48
+      def prime?       # Uses P7 Strictly Prime Generator
+        residues = [1,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,
+          83,89,97,101,103,107,109,113,121,127,131,137,139,143,149,151,157,
+          163,167,169,173,179,181,187,191,193,197,199,209,211]
+        mod=210; # rescnt=48
 
         n = self.abs
         return true  if [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43,
@@ -60,20 +94,21 @@ module Primes
           n%(p+186)== 0 or n%(p+188)==0 or n%(p+198)== 0 or n%(p+200)==0
           p += mod    # first prime candidate for next kth residues group
         end
-        return true
+        true
       end
 
-      def factors(p=13)      # P13 is default prime generator here
-        seeds  = [2, 3, 5, 7, 11, 13, 17, 19]
-        return 'PRIME OPTION NOT A SEEDS PRIME' if !seeds.include? p
+      def factors(p=13)
+        # Return prime factors of n in form [[p1,e1],[p2.e2]..[pn.en]]
+        # Uses sozP13 Sieve of Zakiya (SoZ) as default Prime Generator
+        seeds = [2, 3, 5, 7, 11, 13, 17, 19]
+        p = 13 if !seeds.include? p
 
-        # find primes <= Pn, compute modPn then Prime Gen residues for Pn
-        primes = seeds[0..seeds.index(p)]; mod = primes.reduce(:*)
-        residues=[1]; 3.step(mod,2) {|i| residues << i if mod.gcd(i) == 1}
-        residues << mod+1; rescnt = residues.size-1
+        primes = seeds[0..seeds.index(p)]
+	mod = primes.reduce(:*)   # modulus: modPn = 2*3*5*7*..*Pn
+        residues, rescnt = make_residues_rescnt(mod)
 
-        n = self.abs
-        factors = []
+        n = self.abs              # number to factor
+        factors = []              # init empty factors array
 
         return [] if n == 0
         return [[n,1]] if primes.include? n
@@ -92,76 +127,49 @@ module Primes
         h=Hash.new(0); factors.each {|f| h[f] +=1}; h.to_a.sort
       end
 
-      puts "Using pure ruby versions"
+      puts "Using pure ruby versions for all methods"
     end
   
     # Replace slow ruby library method prime_division with faster version
     alias  prime_division  factors
 
-    def primenth(p=11) # return value of nth prime
+    def primenth(p=7)
       # Return value of nth prime
-      # Uses sozP11 Sieve of Zakiya (SoZ) as default prime sieve
-
-      seeds  = [2, 3, 5, 7, 11, 13, 17, 19]
-      primes = []
+      # Uses sozP7 Sieve of Zakiya (SoZ) as default Prime Generator
+      seeds = [2, 3, 5, 7, 11, 13]
+      p = 7 if !seeds.include? p
 
       n = self.abs                  # the desired nth prime
-      return n != 0 ? seeds[n-1] : 0  if n < seeds.size
-
-      # compute approximate value of (>) nth prime to count up to
-      numb = (n*(Math.log(n)+2)).to_i
-
-      # find primes <= Pn, compute modPn then Prime Gen residues for Pn
-      primes = seeds[0..seeds.index(p)]; mod = primes.reduce(:*)
-      residues=[1]; 3.step(mod,2) {|i| residues << i if mod.gcd(i) == 1}
-      residues << mod+1; rescnt = residues.size-1
-
-      num = numb-1 | 1              # if N even number then subtract 1
-      k=num/mod; modk = mod*k; r=1  # kth residue group; base num value
-      while num >= modk+residues[r]; r += 1 end # compute extra prms size
-      maxprms = k*rescnt + r-1      # max size of prime candidates array
-      prms=Array.new(maxprms,true)  # set all prime candidates to True
-
-      # array of residues offsets to compute nonprimes positions in prms
-      pos =[]; rescnt.times {|i| pos[residues[i]] = i-1};
-
-      # sieve (SoZ) to eliminate nonprimes from prms
-      sqrtN = Math.sqrt(num).to_i
-      modk,r,k=0,0,0
-      prms.each do |prime|
-        r +=1; if r > rescnt; r=1; modk +=mod; k +=1 end
-        next unless prime
-        res_r = residues[r]
-        prime = modk + res_r
-        break if prime > sqrtN
-        prmstep = prime * rescnt
-        residues[1..-1].each do |ri|
-          # compute (prime * (modk + ri)) position index in prms
-          kk,rr  = (res_r * ri).divmod mod  # residues product res[group|track]
-          nonprm = (k*(prime + ri) + kk)*rescnt + pos[rr]
-          while nonprm < maxprms; prms[nonprm]=nil; nonprm +=prmstep end
-        end
-      end
-      # the prms array now has all the primes positions for primes r1..N
-      # count up to nth prime, compute value from address, and output
-      prmcnt = primes.size          # number of primes up to Pn
-      m=0
-      while prmcnt < n; prmcnt +=1 if prms[m]; m +=1 end
-      k,rr = m.divmod rescnt
-      return (mod*k + residues[rr])
+      return n != 0 ? seeds[n-1] : 0  if n <= seeds.size
+      
+      start_num, nth, nthflag = set_start_value(n, nths)
+      return start_num if nthflag   # output nthprime if nth ref value
+
+      num = approximate_nth(n)      # close approx to nth >= real nth
+      primes = seeds[0..seeds.index(p)]
+
+      ks, mod, residues, maxprms, 
+      max_range, prms, prms_range = sozcore2(num, start_num, primes)
+
+      rescnt = residues[1..-1].size
+      pcs2ks = rescnt*ks
+      # starting at start_num's location, find nth prime within given range
+      prms = prms_range if ks > 0
+      prmcnt = n > nth ? nth-1 : primes.size
+      m=0; r=1; modk = mod*ks       # find number of pcs, m, in ks < start_num
+      while modk + residues[r] < start_num; r += 1; m +=1 end
+      pcnt = prmcnt + prms[m..-1].count(1)  # number of primes upto nth approx
+      return "#{pcnt} not enough primes, nth approx too small" if pcnt < n
+      while prmcnt < n; prmcnt +=1 if prms[m] == 1; m +=1 end
+      k, r = (m+pcs2ks).divmod rescnt
+      mod*k + residues[r]
     end
 
     alias  nthprime  primenth       # to make life easier
 
     def primes(start_num=0)
       # Find primes between a number range: end_num - start_num
-      # Use as: end_num.primes(start_num) or end_num.primes
-      # If start_num omitted, will find all primes <= end_num
-      # If start_num > self, values are switched to continue
-      # Output is an array of the primes within the given range
-      # To find count of these primes do: end_num.primes(start_num).size
-      # This method uses the P13 Strictly Prime (SP) Prime Generator (PG)
-
+      # Uses the P13 Strictly Prime (SP) Prime Generator
       num = self.abs;  start_num = start_num.abs
       num, start_num = start_num, num  if start_num > num
 
@@ -169,54 +177,43 @@ module Primes
       plast  = primes.last          # last prime in primes
       return primes.select {|p| p >= start_num && p <= num} if num <= plast
 
-      mod = primes.reduce(:*)       # P13 modulus value 2*3*5*7*11*13
-
-      residues=[1]; plast.step(mod,2) {|i| residues << i if mod.gcd(i) == 1}
-      rescnt = residues.size        # number of residues
-      residues << mod+1             # to make algorithm easier
-
-      num = num-1 | 1               # if N even number then subtract 1
-      k=num/mod; modk = mod*k; r=1  # kth residue group; base num value
-      while num >= modk+residues[r]; r += 1 end # compute extra prms size
-      maxprms = k*rescnt + r-1      # max size of prime candidates array
-      prms=Array.new(maxprms,true)  # set all prime candidates to True
-
-      # hash of residues offsets to compute nonprimes positions in prms
-      pos =[]; rescnt.times {|i| pos[residues[i]] = i-1};
-
-      # sieve (SoZ) to eliminate nonprimes from prms
-      sqrtN= Math.sqrt(num).to_i
-      modk,r,k=0,0,0
-      prms.each do |prime|
-        r +=1; if r > rescnt; r=1; modk +=mod; k +=1 end
-        next unless prime
-        res_r = residues[r]
-        prime = modk + res_r
-        break if prime > sqrtN
-        prmstep = prime * rescnt
-        residues[1..-1].each do |ri|
-          # compute (prime * (modk + ri)) position index in prms
-          kk,rr  = (res_r * ri).divmod mod  # residues product res[group|track]
-          nonprm = (k*(prime + ri) + kk)*rescnt + pos[rr] # 1st prime multiple
-          while nonprm < maxprms; prms[nonprm]=nil; nonprm +=prmstep end
-        end
-      end
-      # the prms array now has all the primes positions for primes r1..N
+      ks, mod, residues, maxprms, 
+      max_range, prms, prms_range = sozcore2(num, start_num, primes)
+ 
+      rescnt = residues[1..-1].size
+      # starting at start_num's location, extract primes within given range
       primes = start_num <= plast ? primes.drop_while {|p| p < start_num} : []
-      k = (start_num-2).abs/mod  # start_num's residue group value
-      modk = mod*k               # start_num's mod group value
-      m = rescnt*k               # number of prms elements up to kth resgroup
-      r = 0                      # begin processing at start of resgroup
-      while m < maxprms
+      if ks > 0; maxprms = max_range; prms = prms_range end
+      m=0; r=1; modk = mod*ks;      # find number of pcs, m, in ks < start_num
+      while modk + residues[r] < start_num; r +=1; m +=1 end
+      (maxprms-m).times do          # find primes from this num pcs within range
+	primes << modk + residues[r] if prms[m] == 1
         r +=1; if r > rescnt; r=1; modk +=mod end
-        if prms[m]
-          prime = modk + residues[r]
-	  primes << prime if prime >= start_num
-        end
-        m +=1
+	m +=1
       end
       primes
     end
+    
+    def primescnt(start_num=0)
+      # Count primes between a number range: end_num - start_num
+      # Uses the P13 Strictly Prime (SP) Prime Generator
+      num = self.abs;  start_num = start_num.abs
+      num, start_num = start_num, num  if start_num > num
+
+      primes = [2,3,5,7,11,13]      # P13 excluded primes lists
+      plast  = primes.last          # last prime in primes
+      return primes.select {|p| p >= start_num && p <= num}.size if num <= plast
+
+      ks, mod, residues, maxprms, 
+      max_range, prms, prms_range = sozcore2(num, start_num, primes)
+
+      # starting at start_num's location, count primes within given range
+      primes = start_num <= plast ? primes.drop_while {|p| p < start_num} : []
+      prms = prms_range if ks > 0
+      m=0; r=1; modk = mod*ks       # find number of pcs, m, in ks < start_num
+      while modk + residues[r] < start_num; r +=1; m +=1 end
+      primecnt = primes.size + prms[m..-1].count(1)
+    end
 
     # Miller-Rabin prime test in Ruby
     # From: http://en.wikipedia.org/wiki/Miller-Rabin_primality_test
@@ -234,10 +231,10 @@ module Primes
       (d >>= 1; s += 1) while d.even?
       k.times do
         a = 2 + rand(n-4)
-        x = a.to_bn.mod_exp(d,n)       #x = (a**d) mod n
+        x = a.to_bn.mod_exp(d,n)      # x = (a**d) mod n
         next if x == 1 or x == n-1
         (s-1).times do
-          x = x.mod_exp(2,n)           #x = (x**2) mod n
+          x = x.mod_exp(2,n)          # x = (x**2) mod n
           return false if x == 1
           break if x == n-1
         end
@@ -245,7 +242,184 @@ module Primes
       end
       true  # with high probability
     end
+
+    def primesmr(start_num=0)
+      # Find primes within a number range: end_num - start_num
+      # Uses 'primemr' to check primality of prime candidates in range
+      sozdata = sozcore1(self, start_num, true)  # true for primes
+      return sozdata[1] if sozdata[0]
+      pcs_in_range, r, mod, modk, rescnt, residues, primes = sozdata[1..-1]
+      pcs_in_range.times do         # find primes from this num pcs in range
+        prime = modk + residues[r]
+	primes << prime if prime.primemr?
+	r +=1; if r > rescnt; r=1; modk +=mod end
+      end
+      primes
+    end
+
+    def primescntmr(start_num=0)
+      # Count primes within a number range: end_num - start_num
+      # Uses 'primemr' to check primality of prime candidates in range
+      sozdata = sozcore1(self, start_num, false) # false for primescnt
+      return sozdata[1] if sozdata[0]
+      pcs_in_range, r, mod, modk, rescnt, residues, primes = sozdata[1..-1]
+      primescnt = primes.size
+      pcs_in_range.times do         # count primes from this num pcs in range
+	primescnt +=1 if (modk + residues[r]).primemr?
+	r +=1; if r > rescnt; r=1; modk +=mod end
+      end
+      primescnt
+    end
+
+    def primes_utils
+      "prime? primemr? primes primesmr primescnt primescntmr primenth|nthprime factors|prime_division"
+    end
+
+    if os_has_factor
+      def primes_utils
+        "prime? primemr? primes primesf primesmr primescnt primescntf primescntmr primenth|nthprime factors|prime_division"
+      end
+    end
+
+    private
+    def make_residues_rescnt(mod)
+      residues=[1]; 3.step(mod,2) {|i| residues << i if mod.gcd(i) == 1}
+      residues << mod+1
+      [residues, residues.size-1]    # return residues array and rescnt
+    end
+
+    def pcs_to_num(num,mod,rescnt,residues) # find number of pcs upto num
+      num = num-1 | 1                # if N even number then subtract 1
+      k=num/mod; modk = mod*k; r=1 # kth residue group; base num value
+      while num >= modk+residues[r]; r += 1 end # compute extra prms size
+      k*rescnt + r-1                 # max number of pcs <= num
+    end
+
+    def pcs_to_start_num(start_num, mod, rescnt, residues)
+      k = (start_num-2).abs/mod     # start_num's residue group value
+      modk = mod*k                  # start_num's mod group value
+      m = rescnt*k                  # number of pcs upto kth resgroup
+      r = 1                         # find r,m for first pc >= start_num
+      while modk + residues[r] < start_num; r +=1; m +=1 end
+      [m, r, modk]                  # parameters for 1st pc >= start_num
+    end
+
+    def sozcore1(num, start_num, method_flag)
+      # Uses the P13 Strictly Prime (SP) Prime Generator
+      num = num.abs;  start_num = start_num.abs
+      num, start_num = start_num, num  if start_num > num
+
+      primes = [2,3,5,7,11,13]      # P13 excluded primes lists
+      plast  = primes.last          # last prime in primes              
+      if num <= plast
+	primes = primes.select {|p| p >= start_num && p <= num}
+	return [true, method_flag ? primes : primes.size]
+      end
+      mod = primes.reduce(:*)       # P13 modulus: 2*3*5*7*11*13 = 30030
+      residues, rescnt = make_residues_rescnt(mod)
+      maxpcs = pcs_to_num(num,mod,rescnt,residues) # num of pcs <= end_num
+
+      # compute parameters for start location and number of pcs within range
+      primes = start_num <= plast ? primes.drop_while {|p| p < start_num} : []
+      m, r, modk = pcs_to_start_num(start_num, mod, rescnt, residues)
+      [false, maxpcs-m, r, mod, modk, rescnt, residues, primes]
+    end
+
+    def sozcore2(num, start_num, primes)
+      mod = primes.reduce(:*)       # modulus: modPn = 2*3*5*7*..*Pn
+      residues, rescnt = make_residues_rescnt(mod)
+      maxprms = pcs_to_num(num,mod,rescnt,residues) # num of pcs <= end_num
+
+      sqrtN = Math.sqrt(num).to_i   # sqrt of end_num (end of range)
+      pcs2sqrtN = pcs_to_num(sqrtN,mod,rescnt,residues) # num of pcs <= sqrtN
+
+      ks = (start_num-2).abs/mod    # start_num's resgroup value
+      maxpcs = maxprms              # if ks = 0 use this for prms array
+      if ks > 0                     # if start_num > mod+1
+	maxpcs = pcs2sqrtN          # find primes in pcs upto sqrtN
+        pcs2ks = rescnt*ks          # number of pcs upto ks resgroup
+        max_range  = maxprms-pcs2ks # number of pcs from ks resgroup to end_num
+        prms_range = Array.new(max_range,1) # pc array to generate range primes
+      end
+      prms=Array.new(maxpcs,1)      # for primes upto sqrtN and end_num if ks=0
+
+      # hash of residues offsets to compute nonprimes positions in prms
+      pos =[]; rescnt.times {|i| pos[residues[i]] = i-1}
+
+      # Sieve of Zakiya (SoZ) to eliminate nonprimes from prms and prms_range
+      modk,r,k=0,0,0
+      pcs2sqrtN.times do |i|        # sieve primes from pcs upto sqrt(end_num)
+        r +=1; if r > rescnt; r=1; modk +=mod; k +=1 end
+	next unless prms[i]==1
+        res_r = residues[r]
+        prime = modk + res_r
+        prmstep = prime * rescnt
+        residues[1..-1].each do |ri|
+          # compute (prime * (modk + ri)) position index in prms
+          kk,rr  = (res_r * ri).divmod mod  # residues product res[group|track]
+          nonprm = (k*(prime + ri) + kk)*rescnt + pos[rr] # 1st prime multiple
+          while nonprm < maxpcs; prms[nonprm]=0; nonprm +=prmstep end
+	  if ks > 0
+	    nonprm = (pcs2ks - nonprm)%prmstep
+	    nonprm = prmstep - nonprm if nonprm != 0
+	    while nonprm < max_range; prms_range[nonprm]=0; nonprm += prmstep end
+	  end
+        end
+      end
+      [ks, mod, residues, maxprms, max_range, prms, prms_range]
+    end
+
+    def approximate_nth(n, b=0.686) # approximate nthprime value >= real value
+      b=0.6863 if n > 1064000000    # good upto nth <= 1122951705
+      a = b*(Math.log(Math.log(n)))
+      (n*(Math.log(n)+a)+1).to_i
+    end
+
+    def set_start_value(n, nths)    # find closest nth|nthprime val <= requested 
+      nthkeys = nths.keys.sort
+      return [nths[n], 0, true] if nthkeys.include? n   # if nth in nths table
+      start_num, nth = 0, nthkeys[0]
+      nthkeys.each {|i| start_num, nth = nths[i], i if n > i}
+      [start_num, nth, false]
+    end
+
+    def nths                        # hash table index of reference nth primes
+      nths={1000000 => 15485863,   5000000 =>   86028121,   7500000 =>  132276691,
+         10000000 =>  179424673,  12500000 =>  227254201,  25000000 =>  472882027,
+         37500000 =>  725420401,  50000000 =>  982451653,  62500000 => 1242809749,
+         75000000 => 1505776939,  87500000 => 1770989609, 100000000 => 2038074743,
+        112500000 => 2306797469, 125000000 => 2576983867, 137500000 => 2848518523,
+        150000000 => 3121238909, 162500000 => 3395057291, 175000000 => 3669829403,
+        187500000 => 3945592087, 200000000 => 4222234741, 212500000 => 4499683009,
+        225000000 => 4777890881, 237500000 => 5056862311, 250000000 => 5336500537,
+        262500000 => 5616787769, 275000000 => 5897707297, 287500000 => 6179208157,
+        300000000 => 6461335109, 312500000 => 6743943629, 325000000 => 7027107881,
+        337500000 => 7310793337, 350000000 => 7594955549, 362500000 => 7879581839,
+        375000000 => 8164628191, 387500000 => 8450100349, 400000000 => 8736028057,
+        412500000 => 9022375487, 425000000 => 9309109471, 437500000 => 9596238593,
+        450000000 => 9883692017, 462500000 =>10171564687, 475000000 =>10459805417,
+        487500000 =>10748372137, 500000000 =>11037271757, 512500000 =>11326513039,
+        525000000 =>11616020609, 537500000 =>11905863799, 550000000 =>12196034771,
+        562500000 =>12486465863, 575000000 =>12777222833, 587500000 =>13068237251,
+        600000000 =>13359555403, 612500000 =>13651119389, 625000000 =>13942985677,
+        637500000 =>14235122851, 650000000 =>14527476781, 662500000 =>14820071503,
+        675000000 =>15112928683, 687500000 =>15406031899, 700000000 =>15699342107,
+        712500000 =>15992957251, 725000000 =>16286768243, 737500000 =>16580801137,
+        750000000 =>16875026921, 762500000 =>17169527171, 775000000 =>17464243799,
+        787500000 =>17759139259, 800000000 =>18054236957, 812500000 =>18349591409,
+        825000000 =>18645104897, 837500000 =>18940846207, 850000000 =>19236701629,
+        862500000 =>19532780327, 875000000 =>19829092147, 887500000 =>20125592731,
+        900000000 =>20422213579, 912500000 =>20719050323, 925000000 =>21016060633,
+        937500000 =>21313231963, 950000000 =>21610588367, 962500000 =>21908128993,
+        975000000 =>22205818561, 987500000 =>22503733657, 1000000000=>22801763489,
+        1012500000=>23099993743, 1025000000=>23398391231, 1037500000=>23696858797,
+        1050000000=>23995554823, 1062500000=>24294392179, 1075000000=>24593421187,
+        1087500000=>24892587403, 1100000000=>25191867719, 1112500000=>25491361037
+      }
+    end
   end
 end
 
-class Integer; include Primes::Utils end
+class Integer; include Primes::Utils end
+  
+puts "Available methods are: #{0.primes_utils}"  # display methods upon loading

data/lib/primes/utils/version.rb

@@ -1,5 +1,5 @@
 module Primes
   module Utils
-    VERSION = "1.1.1"
+    VERSION = "2.0.0"
   end
 end

data/primes-utils.gemspec

@@ -10,14 +10,15 @@ Gem::Specification.new do |spec|
   spec.email         = ["jzakiya@gmail.com"]
 
   spec.summary       = %q{suite of extremely fast utility methods for testing and generating primes}
-  spec.description   = %q{Methods: prime?, primemr?, primes, nthprime/primenth, factors/prime_division}
+  spec.description   = %q{Methods: prime?, primemr?, primes, primesf, primesmr, primescnt, primescntf, primescntmr, nthprime/primenth, factors/prime_division}
   spec.homepage      = "https://github.com/jzakiya/primes-utils"
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.license       = "GPL-2.0"
+  spec.license       = "GPLv2+"
+  spec.required_ruby_version = ">= 1.8.7"
 
   #if spec.respond_to?(:metadata)
   #  spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com' to prevent pushes to rubygems.org, or delete to allow pushes to any server."

metadata

@@ -1,51 +1,63 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: primes-utils
-version: !ruby/object:Gem::Version
-  version: 1.1.1
+version: !ruby/object:Gem::Version 
+  hash: 15
+  prerelease: 
+  segments: 
+  - 2
+  - 0
+  - 0
+  version: 2.0.0
 platform: ruby
-authors:
+authors: 
 - Jabari Zakiya
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-04-06 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2015-05-25 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.9'
-  type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.9'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 29
+        segments: 
+        - 1
+        - 9
+        version: "1.9"
   type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-description: 'Methods: prime?, primemr?, primes, nthprime/primenth, factors/prime_division'
-email:
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 35
+        segments: 
+        - 10
+        - 0
+        version: "10.0"
+  type: :development
+  version_requirements: *id002
+description: "Methods: prime?, primemr?, primes, primesf, primesmr, primescnt, primescntf, primescntmr, nthprime/primenth, factors/prime_division"
+email: 
 - jzakiya@gmail.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
-- ".gitignore"
+
+files: 
+- .gitignore
 - CODE_OF_CONDUCT.md
 - Gemfile
 - README.md
@@ -56,28 +68,40 @@ files:
 - lib/primes/utils/version.rb
 - primes-utils.gemspec
 homepage: https://github.com/jzakiya/primes-utils
-licenses:
-- GPL-2.0
-metadata: {}
+licenses: 
+- GPLv2+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
-  requirements:
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
   - - ">="
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
-  requirements:
+    - !ruby/object:Gem::Version 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
   - - ">="
-    - !ruby/object:Gem::Version
-      version: '0'
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 1.8.25
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: suite of extremely fast utility methods for testing and generating primes
 test_files: []
+
 has_rdoc: 

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: b3c9d1ce71f37ddfef893df9081068e4bed16c1f
-  data.tar.gz: 8c43034d10f57ad8e4753e866c35c52b43da8d37
-SHA512:
-  metadata.gz: f12686ee34059845f8c0525283b1d83a4076676606acce3acbd1b3c58baacd375648c8cb926aaa61b2cb69d9df109f939ec7977e7d158044bf0e028f9df4374f
-  data.tar.gz: 0e6d049b7a9787bce8ceb27cafc224d1a0e05dd8ae7438ed36ae6ecd1916351bd1dedc944e0abc8ac3a77e400edee4d902fe79d9ad71fde02a641199aea44e09