primes-utils 3.0.4 → 3.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bcb2fe6a51dd51f056d5cbbed13be8f50968a3702796f82001fd0f36e1677fd2
-  data.tar.gz: 07de693031de25d727c3e603739d6edea2ed7357ecc5714bb8ea4a8bbd7f48e7
+  metadata.gz: 4389a00aebe98cc43fc901200e8eebdf0ad704f17ce590aafa47b2fe6eadb4e1
+  data.tar.gz: af97630fb433b113734d2d04d68c7f24490373a0aec2e57f411383dccfab53e9
 SHA512:
-  metadata.gz: 5057ba7a07f04a9e51a54823e5b60e72607c8a1efc3855df4e70a62486b637a5851abb5ad875d43172fd55e45bc83d0c121f286031247d485ed49f12bb556705
-  data.tar.gz: 0f72b07258414880b6880e60f4508a3b696098621a979a0146c86a43a6446dfb46bc1332f427f274795cc4e0d56f558e07c8e8583dee201848a7822747cb8e25
+  metadata.gz: 92a9e70b078633b8570ad87057ec006ed3b45c9d9884f01cac28718a24dbf4479fd1429ea9b6d0074f4e8c543fdcf4b1ea912b244bccfe707e78ad1101cc35b7
+  data.tar.gz: 2f1d16062ce8618e22a9c1c1f3b790a3817199400e775d7ad0b0071ace4cfdb96bbd1d4047847316f34398b117f01187f54f48614a5edcaef55cc88cf891fcac

data/README.md

@@ -12,9 +12,6 @@ Available for `FREE` to read|download at:
 
 https://www.academia.edu/19786419/PRIMES_UTILS_HANDBOOK
 
-https://www.scribd.com/doc/266461408/Primes-Utils-Handbook
-
-
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -39,8 +36,8 @@ Then require as:
 
 **prime?**
 
-Determine if an integer value is prime.  Return 'true' or 'false'.
-This replaces the `prime?` method  in the `prime.rb` standard library.
+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?`.
 
 ```
@@ -53,7 +50,7 @@ Uses PGT residues tests, then Miller-Rabin test using `primemr?`.
 
 **primemr?(k=5)**
 
-Optimized deterministic (over 64-bits) implementation of Miller-Rabin algorithm.  
+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.
 
 ```
@@ -62,10 +59,10 @@ n.prime?(6)
 
 **factors or prime_division**
 
-Determine the prime factorization of an +|- integer value.
-Uses Unix coreutils function `factors` if available.
-This replaces the `prime_division` method in the `prime.rb` standard library.
-Multiplying the factors back will produce original number.
+Determine the prime factorization of an +|- integer value.  
+Uses Unix coreutils function `factor` if available.  
+This replaces the `prime_division` method in the `prime.rb` standard library.  
+Multiplying the factors back will produce original number.  
 Output is array of tuples of factors and exponents elements: [[p1, e1], [p2, e2],..,[pn, en]].
 
 ```
@@ -79,28 +76,27 @@ Output is array of tuples of factors and exponents elements: [[p1, e1], [p2, e2]
 
 **factors1**
 
-Pure Ruby version equivalent of `factor`.
-Not as fast as `factor` for some values with multiple large prime factors.
-Always available if OS doesn't have `factor`
+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)**
 
-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`.
-A single input is taken as `end_num`, and the primes <= to it are returned. 
-`primes` is generally faster, and uses SSoZ to compute the range primes.
-`primesmr` is slower, but isn't memory limited, especially for very large numbers|ranges.
-See `PRIMES-UTILS HANDBOOK` for details on best use practices.
+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`.  
+A single input is taken as `end_num`, and the primes <= to it are returned.   
+`primes` is generally faster, and uses SoZ to compute the range primes.  
+`primesmr` is slower, but isn't memory limited, especially for very large numbers|ranges.  
+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]
-300.primes 250 => [251, 257, 263, 269, 271, 277, 281, 283, 293]
+300.primesmr 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]
 101.primes 101 => [101]
 1.primes   => []
@@ -109,11 +105,11 @@ prms => [1000003, 1000033, 1000037, 1000039, 1000081, 1000099]
 
 **primescnt(start=0), 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 SSoZ to identify|count primes from closest hashed value starting point.
-`primescntmr` is slower, but isn't memory limited, especially for very large numbers|ranges.
+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.  
 See `PRIMES-UTILS HANDBOOK` for details on best use practices.
 Also see `Error Handling`.
 
@@ -130,24 +126,24 @@ n=10**8; (25*n).primescnt => 121443371
 
 **primenth(p=0) or nthprime(p=0)**
 
-Return value of the nth prime.
-Default Strictly Prime (SP) Prime Generator (PG) is adaptively selected.
-Can change SP PG used on input. Acceptable primes range: [5, 7].
-Indexed nth primes now upto 7 billionth.
-With 16GB mem can compute upto at least 35.7+ billionth prime (using `bitarray`).
-Returns `nil` for negative nth inputs.
-Also see `Error Handling`.
+Return value of the nth prime.  
+Default Strictly Prime (SP) Prime Generator (PG) is adaptively selected.  
+Can change SP PG used on input. Default is 7. (Usable are 5, 7, 11, but normally just use default.)   
+Indexed nth primes now up to 7 billionth.  
+With 16GB mem can compute up to about 30.7+ billionth prime (using `bitarray`).  
+Returns `nil` for negative nth inputs. Also see `Error Handling`.
 
 ```
 1000000.primenth => 15485863
 1500000.nthprime => 23879519
-2000000.nthprime 11 => 32452843
+2000000.nthprime(7) => 32452843
 1122951705.nthprime => 25741879847
 n = 10**11; n.primenth -> #<NoMemoryError: failed to allocate memory>
 2_123_409_000.nthprime => 50092535639
 4_762_719_305.nthprime => 116378528093
-0.nthprime  => 0
+7_123_456_789.nthprime => 177058934933
 1.primenth  => 2
+0.nthprime  => nil
 -1.nthprime => nil
 ```
 **next_prime**
@@ -175,7 +171,7 @@ Return value of previous prime < n > 2. Returns `nil` for n < 2 (and negatives)
 
 **primes_utils**
 
-Displays a list of all the `primes-utils` methods available for a system.
+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.
@@ -187,7 +183,7 @@ Available methods for 3.0.0.
 ## Error Handling
 With 3.0.0 the Rubygem `bitarray` is used to extend useable memory for `primes`, `primescnt`, and `nthprime`.
 They use private method `sozcores2` to compute the SoZ over the ranges, and returns an array of prime residues positions.
-If an input range exceeds system memory to create the array, it switches to using a `bitarray`.  
+If an input range exceeds system memory to create the array, it switches to using a `bitarray`.
 This greatly extends the computable range sizes, at the expense of being slower than using system memory.
 
 There is also the rare possibility you could get a `NoMemoryError: failed to allocate memory` for the methods 
@@ -212,7 +208,7 @@ All the `primes-utils` methods are `instance_methods` for `Class Integer`.
 
 ## History
 ```
-3.0.0 – YJIT enabled for Ruby >= 3.3, added new methods: next_prime, prev_prime.
+3.0.5 – YJIT enabled for Ruby >= 3.3, added new methods: next_prime, prev_prime.
         Uses 'bitarray' to extend memory use for methods 'nthprime', 'primes', and 'primescnt'.
 2.7.0 – more tweaking adaptive pg selection ranges in select_pg; coded using between? instead of cover?
 2.6.0 – much, much better adaptive pg selection algorithm used in select_pg
@@ -228,7 +224,7 @@ All the `primes-utils` methods are `instance_methods` for `Class Integer`.
         significantly faster resulting from sozcore2 changes; massive code cleanups all-arround; added
         private methods select_pg (to adaptively select the pg used in primes), and array_check (used in
         sozcore2 to catch array creation out-of-memory errors)
-2.3.0 – primescnt now finds primes upto some integer much faster, and for much larger integers
+2.3.0 – primescnt now finds primes up to some integer much faster, and for much larger integers
         increased index nth primes to over 2 billionth; used in nthprime|primenth and primescnt
 2.2.0 – for sozcore2: refactored to include more common code; changed output api; added memory
         error messages when prms and prms_range arrays creation fails; for primenth: used new

data/lib/primes/utils/version.rb

@@ -1,5 +1,5 @@
 module Primes
   module Utils
-    VERSION = "3.0.4"
+    VERSION = "3.0.5"
   end
 end

data/lib/primes/utils.rb

@@ -64,8 +64,8 @@ module Primes
     # Adaptively selects best SP PG, unless valid input PG given at runtime
     def primenth(p = 0)
       return nil if (n = self) < 1
-      seeds = [2, 3, 5, 7, 11, 13]
-      return n > 0 ? seeds[n - 1] : 0 if n <= seeds.size
+      seeds = PRIMES
+      return seeds[n - 1] if n <= seeds.size
 
       start_num, nth, nthflag = set_start_value(n, true)
       return start_num if nthflag      # output nthprime value if n a ref prime key
@@ -326,7 +326,7 @@ module Primes
     def sozcore2(end_num, start_num, modpg)
       residues = make_residues(modpg); rescnt = residues.size     
       maxpcs, pcs2start, rs, modks, pcs_range = pcs_to_nums(end_num, start_num, residues)
-      sqrtN = Integer.sqrt(end_num)
+      sqrtN, inputs_range = Integer.sqrt(end_num), end_num - start_num
       pcs2sqrtN, _ = pcs_to_nums(sqrtN, 0, residues) # num pcs <= sqrtN
 
       m = pcs2start        # index to start retrieving primes in prms array
@@ -346,7 +346,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 distance to start_num
-        next unless (prime - rem <= end_num - start_num) || rem == 0 # skip prime mults not in range
+        next unless (prime - rem <= inputs_range) || rem == 0 # skip prime mults not 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
@@ -368,6 +368,32 @@ module Primes
       (n * (log_n + a) + 3).to_i
     end
 
+    def select_pg(end_num, start_num)       # adaptively select PG
+      range = end_num - start_num
+      pg = 5
+      if start_num <= Integer.sqrt(end_num) # for one array of primes upto N
+        pg =  7 if end_num >  50 * 10**4
+        pg = 11 if end_num > 305 * 10**5
+      else                                  # for split array cases
+        pg =  7 if (range.between?(10**6, 10**7 - 1) && start_num < 10**8)       ||
+                   (range.between?(10**7, 10**8 - 1) && start_num < 46 * 10**8)  ||
+                   (range.between?(10**8, 10**9 - 1) && start_num < 16 * 10**10) ||
+                   (range >= 10**9 && start_num < 26 * 10**12)
+        pg = 11 if (range.between?(10**8, 10**9 - 1) && start_num < 55 * 10**7)  ||
+                   (range >= 10**9 && start_num < 45 * 10**9)
+      end
+      primes = [2, 3, 5, 7, 11, 13].select! { |p| p <= pg }
+      [primes, primes.reduce(:*)]           # [base primes, mod] for PG
+    end
+
+    def array_check(len)                    # for out-of-memory errors on primes array creation
+      begin
+        Array.new(len, 0)                   # use Array when enough mem for given length
+      rescue Exception
+        return BitArray.new(len)            # use BitArray when memory-error for Array
+      end
+    end
+
     # Find largest index nthprime|val <= n; return [start_num, nth, f/t]
     def set_start_value(n, hshflag)
       if hshflag
@@ -488,31 +514,6 @@ module Primes
          6_625_000_000 =>164_167_763_329, 6_750_000_000 => 167_397_013_051,
          6_875_000_000 =>170_628_613_009, 7_000_000_000 => 173_862_636_221 }
     end
-
-    def select_pg(end_num, start_num)       # adaptively select PG
-      range = end_num - start_num
-      pg = 5
-      if start_num <= Integer.sqrt(end_num) # for one array of primes upto N
-        pg =  7 if end_num >  50 * 10**4
-        pg = 11 if end_num > 305 * 10**5
-      else                                  # for split array cases
-        pg =  7 if (range.between?(10**6, 10**7 - 1) && start_num < 10**8)       ||
-                   (range.between?(10**7, 10**8 - 1) && start_num < 46 * 10**8)  ||
-                   (range.between?(10**8, 10**9 - 1) && start_num < 16 * 10**10) ||
-                   (range >= 10**9 && start_num < 26 * 10**12)
-        pg = 11 if (range.between?(10**8, 10**9 - 1) && start_num < 55 * 10**7)  ||
-                   (range >= 10**9 && start_num < 45 * 10**9)
-      end
-      primes = [2, 3, 5, 7, 11, 13].select! { |p| p <= pg }
-      [primes, primes.reduce(:*)]           # [base primes, mod] for PG
-    end
-
-    def array_check(len)                    # for out-of-memory errors on primes array creation
-      begin
-        Array.new(len, 0)                   # use Array when enough mem for given length
-      rescue Exception
-        return BitArray.new(len)            # use BitArray when memory-error for Array
-    end end
   end
 end
 

data/primes-utils-3.0.0.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.files          = FileList['lib/primes/utils.rb', 'lib/primes/utils/*.rb','bin/*', 'README.md', 'Gemfile', 'Rakefile', 'CODE_OF_CONDUCT.md', 'primes-utils-3.0.0.gemspec']
   spec.require_paths = ["lib"]
   spec.license       = "LGPL-2.0-or-later"
-  spec.required_ruby_version = ">= 3.0.1"
+  spec.required_ruby_version = ">= 3.0.0"
 
   spec.add_dependency "bitarray", "~> 1.3", ">= 1.3.1"
   spec.add_development_dependency "bundler", "~> 1.9"

metadata

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