primes-utils 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 20d402c81ad58631f39bc633f955bde445f90e20
-  data.tar.gz: c4ab24dc642cd906197b519d70944330c98012ee
+  metadata.gz: 63a02f55e631a8d239a409e4b140d5323a45cdec
+  data.tar.gz: aeab7ca1a389c6462ef0657998032f9e95020bff
 SHA512:
-  metadata.gz: 558148913ea88891ef1b5c4376fdf645f95c845474cdf04bcb13ff51b337a0b02f58eb230f7d029779f2d1c4a2a511743fee2c4212458b6a7dd6009c029e8acc
-  data.tar.gz: f434c221fbe5756d665ae2ce2681c82ed8b504c31197836dcf37cc2ac111e7be32bea9ebecea0c71c7c06d508785781fd28b3ba041ec4915d4241374d413794c
+  metadata.gz: abe70b780cdf9efc202620c318e06373c710a46203393e4c7798df9502b48a5960ae7a07abafea4ffb2a8d837b3efdd308920a0006a581391eba06534f484caf
+  data.tar.gz: 74faf8fc525138bfc7e29454e986428ae6254ac002bde7596c194c6ee27078783f25f8140532bd8ba3491133a846e7b44d09acd80f57d3bf26ad24d043d297ab

data/.gitignore

@@ -11,4 +11,5 @@
 .directory
 *.odt
 *.odt#
-*.pdf
+*.pdf
+*test*.*

data/README.md

@@ -27,7 +27,7 @@ And then execute:
 Or install it yourself as:
 
     $ gem install primes-utils
-    
+
 Then require as:
 
     require 'primes/utils'
@@ -66,8 +66,8 @@ The reliability can be increased by increasing the default input parameter of k=
 **factors(p=13) or prime_division(p=13)**
 
 Determine the prime factorization of the absolute value of an integer.
-This replaces the `prime division` method in the `prime.rb` standard library.
-Output is array of arrays of factors and exponents: [[p1,e1],[p2,e2]..[pn,en]]
+This replaces the `prime_division` method in the `prime.rb` standard library.
+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].
 
@@ -85,9 +85,10 @@ Can change SP PG used on input. Acceptable primes range: [3 - 19].
 **primes(start=0), primesf(start=0), primesmr(start=0)**
 
 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`
+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.
+Also see `Error Handling`.
 
 ```
 50.primes => [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
@@ -107,9 +108,10 @@ prms => [1000003, 1000033, 1000037, 1000039, 1000081, 1000099]
 **primescnt(start=0), primescntf(start=0), primescntmr(start=0)**
 
 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`
+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.
+Also see `Error Handling`.
 
 ```
 100000.primescnt => 9592
@@ -125,8 +127,8 @@ n=10**400; (n-500).primescntmr(n+500) => 1
 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.
+Indexed nth primes now upto 1.6 billionth.
+Also see `Error Handling`.
 
 ```
 1000000.primenth => 15485863
@@ -134,29 +136,42 @@ An error message will be given if requested nth prime is > than max.
 2000000.nthprime 11 => 32452843
 -500000.nthprime => 7368787
 1122951705.nthprime => 25741879847
-1122951706.primenth => "1122951705 not enough primes, nth approx too small"
 0.nthprime => 0
+1.primenth => 2
 ```
 
 **primes_utils**
 
-Displays a list of all the `primes-utils` methods available for your system. 
+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"
 ```
 
+## Error Handling
+Starting with 2.2.0, error handling has been implemented to gracefully handle when array creation requires more memory than available.
+This occurs then the range size, or end_num, need arrays greater than the amount of avalable memory. The first case shows the message
+`ERROR1: range size too big for available memory.` and the second case `ERROR2: end_num too big for available memory.`
+The affected methods are `nthprime|primenth`, `primes`, and `primescnt`.
+`nthprime|primenth` also displays the error message `<yyyy> not enough primes, approx nth too small.` 
+(where `<yyyy>` is an integer value) when the computed approx_nth value < nth value.
+For all errors, the return value for each method is `nil`.
+
+This behavior is referenced to MRI Ruby.
+
+
 ## Coding Implementations
-The methods `primemr?`, `nthprime/primenth`, `primes`, `primescnt`, `primesmr`, and `primescnt` are coded in pure ruby.
+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 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].
+New in 2.2.0, upon loading with Ruby 1.8 `require 'rubygems'` is invoked to enable installing gems.
 
 All the `primes-utils` methods are `instance_methods` for `class Integer`.
 
@@ -171,6 +186,5 @@ Jabari Zakiya
 [5]https://en.wikipedia.org/wiki/Factor_(Unix)
 [6]https://en.wikipedia.org/wiki/Miller-Rabin_primality_test
 
-
 ## License
 GPLv2+

data/lib/primes/utils.rb

@@ -1,5 +1,7 @@
+# need rubygems to load gems, and rational for 'gcd' method for 1.8
+%w/rubygems rational/.each{|r| require r} if RUBY_VERSION =~ /^(1.8)/
+
 require "primes/utils/version"
-require "rational" if RUBY_VERSION =~ /^(1.8)/   # for 'gcd' method
 
 module Primes
   module Utils
@@ -23,11 +25,11 @@ module Primes
     if os_has_factor   # for platforms with cli 'factor' command
 
       def prime?
-        `factor #{self.abs}`.split(' ').size == 2
+	`factor #{self.abs}`.split(' ').size == 2
       end
 
       def factors(p=0) # p is unused dummy variable for method consistency
-        factors = `factor #{self.abs}`.split(' ')[1..-1].map {|i| i.to_i}
+        factors = `factor #{self.abs}`.split(' ')[1..-1].map(&:to_i)
         h = Hash.new(0); factors.each {|f| h[f] +=1}; h.to_a.sort
       end
 
@@ -98,7 +100,7 @@ module Primes
       end
 
       def factors(p=13)
-        # Return prime factors of n in form [[p1,e1],[p2.e2]..[pn.en]]
+        # 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
@@ -112,9 +114,9 @@ module Primes
 
         return [] if n == 0
         return [[n,1]] if primes.include? n
-        primes.each {|p| while n%p ==0; factors << p; n /= p end }
+        primes.each {|p| while n%p == 0; factors << p; n /= p end }
 
-        sqrtN= Math.sqrt(n).to_i
+        sqrtN = Math.sqrt(n).to_i
         modk,r=0,1; p=residues[1] # first test prime pj
         while p <= sqrtN
           if n%p == 0
@@ -142,24 +144,22 @@ module Primes
       n = self.abs                  # the desired nth prime
       return n != 0 ? seeds[n-1] : 0  if n <= seeds.size
       
-      start_num, nth, nthflag = set_start_value(n, nths)
+      start_num, nth, nthflag = set_start_value(n)
       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)
-
+      prms, m, mod, modk, residues, * = sozcore2(num, start_num, primes)
+      return if prms == nil         # exit gracefully if sozcore2 mem error
+      
       rescnt = residues[1..-1].size
-      pcs2ks = rescnt*ks
+      pcs2ks = rescnt*(modk/mod)    # rescnt*ks - number of pcs upto ks resgroup
+      
       # 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
+      return puts "#{pcnt} not enough primes, approx nth 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]
@@ -177,23 +177,21 @@ module Primes
       plast  = primes.last          # last prime in primes
       return primes.select {|p| p >= start_num && p <= num} if num <= plast
 
-      ks, mod, residues, maxprms, 
-      max_range, prms, prms_range = sozcore2(num, start_num, primes)
- 
+      prms, m, mod, modk, residues, maxprms, r = sozcore2(num, start_num, primes)
+      return if prms == nil         # exit gracefully if sozcore2 mem error
+
       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} : []
-      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
+      while m < maxprms              # find primes from pcs within given range
 	primes << modk + residues[r] if prms[m] == 1
         r +=1; if r > rescnt; r=1; modk +=mod end
 	m +=1
       end
       primes
     end
-    
+
     def primescnt(start_num=0)
       # Count primes between a number range: end_num - start_num
       # Uses the P5 Strictly Prime (SP) Prime Generator
@@ -204,14 +202,11 @@ module Primes
       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)
+      prms, m, * = sozcore2(num, start_num, primes)
+      return if prms == nil         # exit gracefully if sozcore2 mem error
 
       # 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
 
@@ -285,14 +280,14 @@ module Primes
     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
+      [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
+      num = num-1 | 1               # if N even number then subtract 1
+      k=num/mod; modk = mod*k; r=1  # init parameters for kth resgroup
+      while num >= modk+residues[r]; r += 1 end # find pc location r >= num
+      rescnt*k + r-1                # max number of pcs <= num
     end
 
     def pcs_to_start_num(start_num, mod, rescnt, residues)
@@ -300,8 +295,8 @@ module Primes
       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
+      while modk + residues[r] < start_num; r +=1 end
+      [m+r-1, r, modk]              # parameters for 1st pc >= start_num
     end
 
     def sozcore1(num, start_num, method_flag)
@@ -325,6 +320,16 @@ module Primes
       [false, maxpcs-m, r, mod, modk, rescnt, residues, primes]
     end
 
+    # Perform SoZ for given Prime Generator and return array of parameters
+    # inputs:  end_num and start_num of range; excluded primes array for PG
+    # outputs: prms - binary (0,1) array of pcs within a range or to end_num
+    #          m    - r-1, num of pcs in ks before start_num residue r
+    #          mod  - modulus value for PG
+    #          modk - mod*ks; mod value for ks, start_num's resgroup
+    #          residues - array of residues plus mod+1 for PG
+    #          maxprms  - the number of pcs in range to find primes from
+    #          r    - first residue location in ks >= start_num
+
     def sozcore2(num, start_num, primes)
       mod = primes.reduce(:*)       # modulus: modPn = 2*3*5*7*..*Pn
       residues, rescnt = make_residues_rescnt(mod)
@@ -335,13 +340,21 @@ module Primes
 
       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
+      begin                         # start arrays mem error handling block
+        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
+	  begin
+            prms_range = Array.new(max_range,1) # pc array to hold range primes
+	    rescue                  # for not enough memory error for prms_range
+	      return puts "ERROR1: range size too big for available memory."
+	  end  
+	end
+        prms=Array.new(maxpcs,1)    # for primes upto sqrtN and end_num if ks=0
+        rescue                      # for not enough memory error for prms
+	  return puts "ERROR2: end_num too big for available memory."
+      end                           # method return value is `nil` upon error
 
       # hash of residues offsets to compute nonprimes positions in prms
       pos =[]; rescnt.times {|i| pos[residues[i]] = i-1}
@@ -360,27 +373,32 @@ module Primes
           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
+	    nonprm = (pcs2ks - nonprm)%prmstep        # translate current prime to ks
+	    nonprm = prmstep - nonprm if nonprm != 0  # determine its location
 	    while nonprm < max_range; prms_range[nonprm]=0; nonprm += prmstep end
 	  end
         end
       end
-      [ks, mod, residues, maxprms, max_range, prms, prms_range]
+
+      if ks > 0; prms = prms_range; maxprms = max_range end
+      r=1; modk = mod*ks                              # find 1st residue val|location
+      while modk + residues[r] < start_num; r +=1 end # r in ks >= start_num
+
+      [prms, m=r-1, mod, modk, residues, maxprms, r]  # parameter output
     end
 
-    def approximate_nth(n, b=0.686) # approximate nthprime value >= real value
-      b=0.6863 if n > 1064000000    # good upto nth <= 1122951705
+    def approximate_nth(n)          # approximate nthprime value >= real value
+      b = 0.5722*n**0.0088          # derived equation to compute close nth values
       a = b*(Math.log(Math.log(n)))
-      (n*(Math.log(n)+a)+1).to_i
+      (n*(Math.log(n)+a)+3).to_i    # use nth approximation as end_num of range
     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
+    def set_start_value(n)          # find closest index nthprime <= requested nth
+      nthkeys = nths.keys.sort      # create array of indexed nth numbers
+      return [nths[n], 0, true] if nthkeys.include? n  # if n 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]
+      [start_num, nth, false]       # use index prime value as start_num of range
     end
 
     def nths                        # hash table index of reference nth primes
@@ -414,7 +432,20 @@ module Primes
         975000000 =>22205818561, 987500000 =>22503733657, 1000000000=>22801763489,
         1012500000=>23099993743, 1025000000=>23398391231, 1037500000=>23696858797,
         1050000000=>23995554823, 1062500000=>24294392179, 1075000000=>24593421187,
-        1087500000=>24892587403, 1100000000=>25191867719, 1112500000=>25491361037
+        1087500000=>24892587403, 1100000000=>25191867719, 1112500000=>25491361037,
+        1125000000=>25790970053, 1137500000=>26090709563, 1150000000=>26390560513,
+        1162500000=>26690560601, 1175000000=>26990744987, 1187500000=>27291009337,
+        1200000000=>27591444869, 1212500000=>27892051267, 1225000000=>28192760279,
+        1237500000=>28493648629, 1250000000=>28794583627, 1262500000=>29095694269,
+        1275000000=>29396966971, 1287500000=>29698366099, 1300000000=>29999858327,
+        1312500000=>30301430881, 1325000000=>30603183581, 1337500000=>30905024497,
+        1350000000=>31207047449, 1362500000=>31509131153, 1375000000=>31811397571,
+        1387500000=>32113702069, 1400000000=>32416190071, 1412500000=>32718790873,
+        1425000000=>33021414143, 1437500000=>33324275711, 1450000000=>33627220709,
+        1462500000=>33930284893, 1475000000=>34233442279, 1487500000=>34536683891,
+        1500000000=>34840062373, 1512500000=>35143545889, 1525000000=>35447088559,
+        1537500000=>35750747297, 1550000000=>36054501641, 1562500000=>36358440731,
+        1575000000=>36662430631, 1587500000=>36966563321, 1600000000=>37270791697
       }
     end
   end

data/lib/primes/utils/version.rb

@@ -1,5 +1,5 @@
 module Primes
   module Utils
-    VERSION = "2.1.0"
+    VERSION = "2.2.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: primes-utils
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Jabari Zakiya
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-05-25 00:00:00.000000000 Z
+date: 2015-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -76,7 +76,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: suite of extremely fast utility methods for testing and generating primes