primes-utils 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 02ae799a48a427c43b317bd72d0c610fb2fd61c2
+  data.tar.gz: bc2dae709f9f666b50a83c0fe70c25d9f1d5251c
+SHA512:
+  metadata.gz: 07f57ffe182198ec1f90d318586edfda8b10371e5f0a74a3a7303dcb4c224f716145863ef1ede2b69a36c0402df4b5f9f4dbc64bcc98191d916a3e22fce2b4c3
+  data.tar.gz: f078d942fa9ebb6b8f98b4b2343f27fac5f89e43241989ff7ecd0a04b66561ecb15daf7c330d2191ce63d1f86d048ecc365d2e3e4c6e96a886755debf4bd0084

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in primes-utils.gemspec
+gemspec

data/README.md

@@ -0,0 +1,106 @@
+# 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.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'primes-utils'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install primes-utils
+
+## Methods
+
+**prime?**
+Determine if the absolute value of an integer is prime.  Return 'true' or 'false'.
+This replaces the `prime?` method  in the `prime.rb` standard library.
+```
+101.prime? => true
+100.prime? => false
+-71.prime? => true
+```
+**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.
+```
+1111111111111111111.primemr?  => true
+1111111111111111111.primemr? 50  => true
+1111111111111111111.primemr?(50) => true
+11111111111111111111.primemr? => false
+-3333333333333333333.primemr? => false
+```
+**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.
+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
+Default Strictly Prime (SP) Prime Generator (PG) used here is P13.
+Can change SP PG used on input.  Acceptable range are primes from 3 - 19.
+```
+1111111111111111111.prime_division => [[1111111111111111111, 1]]
+11111111111111111111.prime_division  => [[11, 1], [41, 1], [101, 1], [271, 1], [3541, 1], [9091, 1], [27961, 1]]
+123456789.factors  => [[3, 2], [3607, 1], [3803, 1]]
+123456789.factors 17 => [[3, 2], [3607, 1], [3803, 1]]
+123456789.factors(17) => [[3, 2], [3607, 1], [3803, 1]]
+-12345678.factors => [[2, 1], [3, 2], [47, 1], [14593, 1]]
+```
+**primes(start_num=0)**
+Create an array of primes from the range start_num - end_num.
+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.
+```
+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]
+300.primes 250  => [251, 257, 263, 269, 271, 277, 281, 283, 293]
+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]
+```
+**primenth(p=11) or nthprime(p=11)**
+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 range are primes from 3 - 19.
+```
+1000000.primenth  => 15485863
+1500000.nthprime  => 23879519
+2000000.nthprime 13  => 32452843
+-500000.nthprime  => 7368787
+```
+## 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].
+
+Upon loading, the gem tests if the host `RUBY_PLATFORM` value is contained in a list
+of known OSes which has the `factor` command. If so, it wraps a system call to `factor` 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]. OSes not on the list that have `factor`
+can be added to the `factor_platforms` array to accommodate them.
+
+## Author
+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
+[5]https://en.wikipedia.org/wiki/Factor_(Unix)
+
+## License
+GPL 2.0 or later.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "primes/utils"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/primes/utils.rb

@@ -0,0 +1,244 @@
+require "primes/utils/version"
+
+module Primes
+  module Utils
+    private
+    factor_platforms = %w/linux bsd unix/
+    os_has_factor = factor_platforms.any? {|p| RUBY_PLATFORM.match(p)}
+
+    public
+    if os_has_factor   # for platforms with cli 'factor' command
+
+      def prime?
+        `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}
+        h = Hash.new(0); factors.each {|f| h[f] +=1}; h.to_a.sort
+      end
+
+      puts "Using cli 'factor' for prime?/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
+
+        n = self.abs
+        return true  if [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,
+                       107, 109, 113, 127, 131, 137, 139, 149, 151, 157,163,
+                       167, 173, 179, 181, 191, 193, 197, 199, 211].include? n
+        return false if not residues.include?(n%mod) || n == 1
+
+        sqrtN = Math.sqrt(n).to_i
+        p=11          # first test prime pj
+        while p <= sqrtN
+          return false if
+          n%(p)    == 0 or n%(p+2)  ==0 or n%(p+6)  == 0 or n%(p+8)  ==0 or
+          n%(p+12) == 0 or n%(p+18) ==0 or n%(p+20) == 0 or n%(p+26) ==0 or
+          n%(p+30) == 0 or n%(p+32) ==0 or n%(p+36) == 0 or n%(p+42) ==0 or
+          n%(p+48) == 0 or n%(p+50) ==0 or n%(p+56) == 0 or n%(p+60) ==0 or
+          n%(p+62) == 0 or n%(p+68) ==0 or n%(p+72) == 0 or n%(p+78) ==0 or
+          n%(p+86) == 0 or n%(p+90) ==0 or n%(p+92) == 0 or n%(p+96) ==0 or
+          n%(p+98) == 0 or n%(p+102)==0 or n%(p+110)== 0 or n%(p+116)==0 or
+          n%(p+120)== 0 or n%(p+126)==0 or n%(p+128)== 0 or n%(p+132)==0 or
+          n%(p+138)== 0 or n%(p+140)==0 or n%(p+146)== 0 or n%(p+152)==0 or
+          n%(p+156)== 0 or n%(p+158)==0 or n%(p+162)== 0 or n%(p+168)==0 or
+          n%(p+170)== 0 or n%(p+176)==0 or n%(p+180)== 0 or n%(p+182)==0 or
+          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
+      end
+
+      def factors(p=13)      # P13 is default prime generator here
+        seeds  = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41]
+        return 'PRIME OPTION NOT A SEEDS PRIME' 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
+
+        n = self.abs
+        factors = []
+
+        return [] if n == 0
+        return [[n,1]] if primes.include? n
+        primes.each {|p| while n%p ==0; factors << p; n /= p end }
+
+        sqrtN= Math.sqrt(n).to_i
+        modk,r=0,1; p=residues[1] # first test prime pj
+        while p <= sqrtN
+          if n%p == 0
+            factors << p; r -=1; n /= p; sqrtN = Math.sqrt(n).to_i
+          end
+          r +=1; if r > rescnt; r=1; modk +=mod end
+          p = modk+residues[r]    # next (or current) prime candidate
+        end
+        factors << n if n > 1
+        h=Hash.new(0); factors.each {|f| h[f] +=1}; h.to_a.sort
+      end
+
+      puts "Using pure ruby versions"
+    end
+  
+    # Replace slow ruby library method prime_division with faster version
+    alias  prime_division  factors
+
+    def primenth(p=11) # return value of nth prime
+      # Return value of nth prime
+      # Uses sozP11 Sieve of Zakiya (SoZ) as default prime sieve
+
+      seeds  = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41]
+      primes = []
+
+      n = self.abs # the desired nth prime
+      return seeds[n-1] if n < 14
+      numb = 22*n  # approx value need to check primes up to
+
+      # 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
+      # find the nth prime and output it
+      count = primes.size
+      modk,r=0,0
+      prms.each do |prime|
+        r +=1; if r > rescnt; r=1; modk +=mod end
+        count +=1 if prime
+        return modk+residues[r] if count == n
+      end
+    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
+
+      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
+
+      return primes.select {|p| p >= start_num && p <= num} if num <= 13
+
+      mod = 30030                   # P13 modulus value 2*3*5*7*11*13
+
+      residues=[1]; 17.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
+      primes = start_num <= 13 ? primes.drop_while {|p| p < start_num} : []
+      k = start_num / mod
+      modk = mod*k
+      m = rescnt*k
+      r = 0
+      while m < maxprms
+        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
+      end
+      primes
+    end
+
+    # Miller-Rabin prime test in Ruby
+    # From: http://en.wikipedia.org/wiki/Miller-Rabin_primality_test
+    # Ruby Rosetta Code: http://rosettacode.org/wiki/Miller-Rabin_primality_test
+    # I modified the Rosetta Code, as shown below
+
+    require 'openssl'
+    def primemr?(k=20) # increase k for more reliability
+      n = self.abs
+      return true  if n == 2 or n == 3
+      return false if n % 6 != 1 && n % 6 != 5 or n == 1
+
+      d = n - 1
+      s = 0
+      (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
+        next if x == 1 or x == n-1
+        (s-1).times do
+          x = x.mod_exp(2,n)           #x = (x**2) mod n
+          return false if x == 1
+          break if x == n-1
+        end
+        return false if x != n-1
+      end
+      true  # with high probability
+    end
+  end
+end
+
+class Integer; include Primes end

data/lib/primes/utils/version.rb

@@ -0,0 +1,5 @@
+module Primes
+  module Utils
+    VERSION = "1.0.0"
+  end
+end

data/primes-utils.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'primes/utils/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "primes-utils"
+  spec.version       = Primes::Utils::VERSION
+  spec.authors       = ["Jabari Zakiya"]
+  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.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"]
+
+  #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."
+  #end
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: primes-utils
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jabari Zakiya
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-04-01 00:00:00.000000000 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'
+  type: :development
+  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:
+- jzakiya@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/primes/utils.rb
+- lib/primes/utils/version.rb
+- primes-utils.gemspec
+homepage: https://github.com/jzakiya/primes-utils
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: suite of extremely fast utility methods for testing and generating primes
+test_files: []
+has_rdoc: