prime_lib 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 648f92351097b6d1df329f8fc3f87497852c098d
+  data.tar.gz: 1f641e1d56f54b6f919e08a8fa790b7ffc7289fd
+SHA512:
+  metadata.gz: 415051537d123ca4b6329cc39dd249caf9775a187141d9397cdd7f32d619d9a63ea4660dab0ccd8b0a42eae8806b1d4cc7ae3f912ebb4fa4b4466013aa910f33
+  data.tar.gz: 964c19325578dc3c77cc9e1d28a21b1958911f4357851e8898b9854f5c9231cf8271058e956d14158281311d7f25e3623e48202e92d12b9d6155f05678b4109f

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    prime_lib (0.1.0)
+      RubyInline (~> 3.12.2)
+      terminal-table
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    RubyInline (3.12.2)
+      ZenTest (~> 4.3)
+    ZenTest (4.9.5)
+    awesome_print (1.2.0)
+    diff-lcs (1.2.5)
+    rake (10.1.1)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+    terminal-table (1.4.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  awesome_print
+  prime_lib!
+  rake
+  rspec

data/LICENCE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Adit
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,36 @@
+# PrimeLib
+
+This gem generates a table of the product of N prime numbers.
+Current version aims to improve its performance on prime numbers retrieval.
+
+## Installation
+
+Gemfile:
+
+    gem 'prime_lib', '~> 0.1.0'
+
+## Usage (in terminal)
+
+    > puts PrimeLib::GeneratorProduct.new(10).to_table
+
+
+## WHAT I'VE DONE
+
+1. Optimization of prime generation based on Sieve of Eratosthenes algorithm
+    
+    Currently my implementation runs slightly faster[1] than sieve generator of Ruby 2.0 Prime lib[2] which has been greatly improved 6 month ago by Yugui[3].
+    
+    [1] Ruby Lib takes roughly 1 sec to calculate 200,000 primes, my lib takes 0.6 secs  
+    [2] https://github.com/ruby/ruby/blob/trunk/lib/prime.rb  
+    [3] https://github.com/ruby/ruby/commit/def83bff91d59fa5fdd1898f903f9000ad1dbe13#diff-cb376f8d9ff85c3dbf97cd71a7463898
+
+2. To maximize performance gain I decided to run on C code
+    
+    
+    > PrimeLib::Generator.new(n_samples, engine: PrimeLib::Generator::SieveOfEratosthenesC.new).to_a
+    
+  Known issues:
+   - Ruby Inline C compiler throws some[1] warnings I should optimize, meanwhile I've not experienced any trouble (tested till 20_000_000 primes)  
+   [1] "left-hand operand of comma expression has no effect",  
+       "passing argument 3 of ‘rb_ary_store’ makes integer from pointer without a cast"
+ 

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec) do |spec|
+    spec.pattern = 'spec/**/*_spec.rb'
+    spec.rspec_opts = ['--color']
+  end
+  task :default => :spec  
+rescue LoadError
+  nil
+end

data/lib/prime_lib/decorator/table.rb

@@ -0,0 +1,27 @@
+module PrimeLib
+  
+  module Decorator
+    
+    module Table
+      
+      def lister_keys
+        %W(i Prime)
+      end
+      
+      def lister
+        primes = []
+        each_with_index do |i, prime|
+          primes << [i, prime.to_i]
+        end
+        primes
+      end
+      
+      def to_table
+        ::Terminal::Table.new :headings => lister_keys, :rows => lister
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/prime_lib/decorator/table_product.rb

@@ -0,0 +1,27 @@
+module PrimeLib
+  
+  module Decorator
+    
+    module TableProduct
+      
+      def lister_keys
+        %W(i Prime Product)
+      end
+      
+      def lister
+        primes = []
+        each_with_index do |i, prime, product|
+          primes << [i, prime, product]
+        end
+        primes
+      end
+      
+      def to_table
+        ::Terminal::Table.new :headings => lister_keys, :rows => lister
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/prime_lib/generator/gen_engine.rb

@@ -0,0 +1,25 @@
+module PrimeLib
+  
+  class Generator
+    
+    class GenEngine
+      
+      include Enumerable
+      
+      attr_accessor :max_els
+      attr_reader :primes
+      
+      def initialize(max_els = 10)
+        @max_els = max_els
+        @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]
+      end
+      
+      def retrieve_primes
+        raise 'define me'
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/prime_lib/generator/sieve_of_eratosthenes.rb

@@ -0,0 +1,47 @@
+module PrimeLib
+  
+  class Generator
+    
+    class SieveOfEratosthenes < GenEngine
+      
+      def initialize(max_els = 10)
+        super
+        @max_checked = @primes.last + 1
+      end
+      
+      def retrieve_primes
+        next_batch while primes.size <= max_els
+        primes.take(max_els)
+      end
+      
+      private
+        
+        def next_batch
+          max_segment_size = 1e6.to_i
+          max_cached_prime = @primes.last
+
+          segment_min = @max_checked
+          segment_max = [segment_min + max_segment_size, max_cached_prime * 2].min
+          
+          root = Math.sqrt(segment_max).floor
+          
+          sieving_primes = @primes[1..-1].take_while { |prime| prime <= root } # 3 5 7 11 13
+          segment = ((segment_min + 1) .. segment_max).step(2).to_a
+          
+          sieving_primes.each do |sieving_prime| # 102 103 104 105 106 ~ 3 5 7 11 13 -> 1 1 1 9 7
+            cursor = (-(segment_min + 1 + sieving_prime) / 2) % sieving_prime
+            while cursor <= segment.size
+              segment[cursor] = nil
+              cursor += sieving_prime
+            end
+          end
+          
+          @primes = @primes + segment.compact
+          @max_checked = segment_max
+        end
+        
+    end
+    
+  end
+  
+end

data/lib/prime_lib/generator/sieve_of_eratosthenes_c.rb

@@ -0,0 +1,74 @@
+module PrimeLib
+  
+  class Generator
+    
+    class SieveOfEratosthenesC < GenEngine
+      
+      def initialize(max_els = 10)
+        super
+        @max_checked = @primes.last + 1
+      end
+      
+      def retrieve_primes
+        max_segment_size = 1e6.to_i
+        
+        while primes.size <= max_els do
+          max_cached_prime = @primes.last
+
+          segment_min = @max_checked
+          segment_max = [segment_min + max_segment_size, max_cached_prime * 2].min
+          
+          @primes = @primes + next_batch(@primes, segment_min, segment_max).reject{|el| el == false }
+          @max_checked = segment_max
+        end
+        
+        primes.take(max_els)
+      end
+      
+      inline(:C) do |builder|
+        builder.c <<-EOC
+          static VALUE next_batch(VALUE primes, double segment_min, double segment_max)
+          {
+            int i;
+            int root = sqrt(segment_max);
+            
+            VALUE sieving_primes = rb_ary_new();
+            int prime;
+            
+            VALUE segment = rb_ary_new();
+            
+            int neg_offset, cursor;
+            
+            for (i = 1; i < RARRAY_LEN(primes), (prime = NUM2DBL(rb_ary_entry(primes, i))) <= root; i++) {
+              rb_ary_push(sieving_primes, INT2NUM(prime) );
+            }
+            
+            for (i = segment_min + 1; i < segment_max; i += 2) {
+              rb_ary_push(segment, INT2NUM(i));
+            }
+            
+            for (i = 0; i < RARRAY_LEN(sieving_primes); i++) {
+              int sieving_prime = NUM2DBL(rb_ary_entry(sieving_primes, i));
+          
+              neg_offset = (-(segment_min + 1 + sieving_prime) / 2);
+              cursor = neg_offset + (int)((neg_offset < 0 ? -neg_offset : neg_offset) / sieving_prime) * sieving_prime;
+              if (cursor < 0) {
+                cursor += sieving_prime;
+              }
+              
+              while(cursor <= RARRAY_LEN(segment)){
+                rb_ary_store(segment, cursor, NULL);
+                cursor += sieving_prime;
+              }
+            }
+            
+            return segment;
+          }
+        EOC
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/prime_lib/generator.rb

@@ -0,0 +1,32 @@
+module PrimeLib
+  
+  class Generator
+    extend Forwardable
+    
+    include PrimeLib::Decorator::Table
+    
+    def_delegators :@engine, :retrieve_primes
+    
+    def initialize(max_els = 100, engine: SieveOfEratosthenes.new)
+      @engine = engine
+      engine.max_els = max_els
+      @max_els = max_els
+    end
+    
+    def method_added(method)
+      (class<< self;self;end).def_delegator :instance, method
+    end
+    
+    def each_with_index
+      retrieve_primes.each_with_index do |prime, iprime|
+        yield(prime, iprime)
+      end
+    end
+    
+    def to_a
+      retrieve_primes
+    end
+    
+  end
+  
+end

data/lib/prime_lib/generator_product.rb

@@ -0,0 +1,28 @@
+module PrimeLib
+  
+  class GeneratorProduct < Generator
+    include PrimeLib::Decorator::TableProduct
+    
+    def initialize(*args)
+      super(*args)
+      @product = 1
+    end
+    
+    def each_with_index
+      retrieve_primes.each_with_index do |prime, iprime|
+        @product *= prime
+        yield(iprime, prime, @product)
+      end
+    end
+    
+    def to_a
+      ret_primes = []
+      each_with_index do |iprime, prime, product|
+        ret_primes << [iprime, prime, product]
+      end
+      ret_primes
+    end
+    
+  end
+  
+end

data/lib/prime_lib/version.rb

@@ -0,0 +1,3 @@
+module PrimeLib
+  VERSION = "0.1.0"
+end

data/lib/prime_lib.rb

@@ -0,0 +1,19 @@
+require 'inline'
+require 'forwardable'
+require 'terminal-table'
+require 'prime_lib/version'
+
+require 'prime_lib/decorator/table'
+require 'prime_lib/decorator/table_product'
+
+require 'prime_lib/generator'
+require 'prime_lib/generator_product'
+require 'prime_lib/generator/gen_engine'
+require 'prime_lib/generator/sieve_of_eratosthenes'
+require 'prime_lib/generator/sieve_of_eratosthenes_c'
+
+module PrimeLib
+  
+  ROOT_PATH = File.expand_path '../..', __FILE__
+  
+end

data/prime_lib.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'prime_lib/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "prime_lib"
+  gem.version       = PrimeLib::VERSION
+  gem.authors       = ["Adit"]
+  gem.email         = ["a.saxena@email.it"]
+  gem.description   = "Write a program that calculates and prints out a multiplication table of the first 10 calculated prime numbers."
+  gem.summary       = "The program must run from the command line and print to screen 1 table.\nAcross the top and down the left side should be the 10 primes, and the body of the table should contain the product of multiplying these numbers."
+
+  gem.homepage      = "https://bitbucket.org/aditsaxena/prime_lib/src"
+
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  
+  gem.files         = `git ls-files`.split($/)
+  # s.files         = Dir["[A-Z]*[^~]"] + Dir["lib/**/*.rb"] + Dir["spec/*"] + [".gitignore"]
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  
+  gem.require_paths = ["lib"]
+  
+  gem.add_dependency "RubyInline", "~> 3.12.2"
+  
+  gem.add_dependency "terminal-table"
+  
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "awesome_print"
+  
+end

data/spec/decorator/table_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe "PrimeLib" do
+  
+  it "Prints a table of first N primes" do
+    primelib = PrimeLib::Generator.new(10)
+    puts primelib.to_table
+  end
+  
+  it "Prints a table of first N primes products" do
+    primelib = PrimeLib::GeneratorProduct.new(10)
+    puts primelib.to_table
+  end
+  
+  it "Prints a table of first N primes products", focus: true do
+    primelib = PrimeLib::GeneratorProduct.new(10, engine: PrimeLib::Generator::SieveOfEratosthenesC.new)
+    puts primelib.to_table
+  end
+  
+    # primes = PrimeLib::Generator.new(n_samples, engine: PrimeLib::Generator::SieveOfEratosthenesC.new).to_a
+  
+end

data/spec/generator/generator_product_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe PrimeLib::Generator do
+  
+  it "provides a multiplication list of the first N primes" do
+    qty = 30
+    qty.should be > 1
+    
+    primes_prods = PrimeLib::GeneratorProduct.new(qty).to_a
+    manual_prod = 1
+    
+    (qty - 1).times do |i|
+      manual_prod = manual_prod * primes_prods[i][1]
+      expect(manual_prod).to eq primes_prods[i][2]
+    end
+    
+  end
+  
+end

data/spec/generator/generator_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe PrimeLib::Generator do
+  
+  let(:first_primes) {
+    # http://primes.utm.edu/lists/small/1000.txt
+    %W(   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    223    227    229 
+      233    239    241    251    257    263    269    271    277    281 
+      283    293    307    311    313    317    331    337    347    349 
+      353    359    367    373    379    383    389    397    401    409 
+      419    421    431    433    439    443    449    457    461    463 
+      467    479    487    491    499    503    509    521    523    541 
+      547    557    563    569    571    577    587    593    599    601 
+      607    613    617    619    631    641    643    647    653    659 
+      661    673    677    683    691    701    709    719    727    733 
+      739    743    751    757    761    769    773    787    797    809 
+      811    821    823    827    829    839    853    857    859    863 
+      877    881    883    887    907    911    919    929    937    941 
+      947    953    967    971    977    983    991    997   1009   1013 
+     1019   1021   1031   1033   1039   1049   1051   1061   1063   1069 
+     1087   1091   1093   1097   1103   1109   1117   1123   1129   1151 
+     1153   1163   1171   1181   1187   1193   1201   1213   1217   1223 
+     1229   1231   1237   1249   1259   1277   1279   1283   1289   1291 
+     1297   1301   1303   1307   1319   1321   1327   1361   1367   1373 
+     1381   1399   1409   1423   1427   1429   1433   1439   1447   1451 
+     1453   1459   1471   1481   1483   1487   1489   1493   1499   1511 
+     1523   1531   1543   1549   1553   1559   1567   1571   1579   1583 
+     1597   1601   1607   1609   1613   1619   1621   1627   1637   1657 
+     1663   1667   1669   1693   1697   1699   1709   1721   1723   1733 ).map{ |el| el.to_i }
+   }
+  
+  it "fetches N primes, test with a precalculated list" do
+    n_samples = 100
+    primes = PrimeLib::Generator.new(n_samples).to_a
+    expect(primes).to eq first_primes.take(n_samples)
+  end
+  
+  it "fetches N primes, with C code" do
+    n_samples = 100
+    primes = PrimeLib::Generator.new(n_samples, engine: PrimeLib::Generator::SieveOfEratosthenesC.new).to_a
+    expect(primes.to_a).to eq first_primes.take(n_samples)
+  end
+  
+  it "fetches N primes, test with regex" do
+    primes = PrimeLib::Generator.new(1000).to_a
+    
+    for i in 0..1000
+      is_prime = primes.include?(i)
+      expect(RegexPrime.is_prime? i).to eq is_prime
+    end
+  end
+  
+end

data/spec/performance/performance_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe "PrimeLib" do
+  
+  let(:prime_200_000th) { 2750159 } # http://is.2750159.aprimenumber.com/
+  
+  it "compares Ruby 2.0 Prime class" do
+    std_class_prime = Prime::EratosthenesGenerator.new
+    std_class_last = 200_000.times.map { std_class_prime.next }.last
+    expect(std_class_last).to eq prime_200_000th
+  end
+  
+  it "produces same values as standard Ruby 2.0 Prime class" do
+    primelib = PrimeLib::Generator.new(200_000)
+    primelib_last = primelib.to_a.last
+    expect(primelib_last).to eq prime_200_000th
+  end
+  
+  it "can speed its calculation time piping directly C code" do
+    primelib = PrimeLib::Generator.new(200_000, engine: PrimeLib::Generator::SieveOfEratosthenesC.new)
+    
+    primelib_last = primelib.to_a.last
+    expect(primelib_last).to eq prime_200_000th
+  end
+  
+  it "have an performance improvement over its competitor" do
+    Benchmark.bm(1) do |bm|
+      bm.report("Prime Ruby 2.0     "){ prime = Prime::EratosthenesGenerator.new ; 200_000.times.map { prime.next }.last }
+      bm.report("My implem. in ruby "){ primelib = PrimeLib::Generator.new(200_000) ; primelib.to_a.last }
+      bm.report("My implem. inline C"){ primelib = PrimeLib::Generator.new(200_000, engine: PrimeLib::Generator::SieveOfEratosthenesC.new) ; primelib.to_a.last }
+    end 
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require "benchmark"
+require "awesome_print"
+require "prime_lib"
+
+Dir["#{PrimeLib::ROOT_PATH}/spec/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.order = "random" # --seed 1234
+  
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+  
+  # Coloring stuff
+  config.color_enabled = true # Use color in STDOUT
+  config.tty = true
+  
+  # config.include MyTestingHelpers #, :type => :controller # http://stackoverflow.com/questions/20614213/how-to-include-a-support-file-in-rails-4-for-rspec
+  
+end

data/spec/support/original_prime.rb

@@ -0,0 +1,500 @@
+# https://github.com/ruby/ruby/blob/trunk/lib/prime.rb
+#
+# = prime.rb
+#
+# Prime numbers and factorization library.
+#
+# Copyright::
+#   Copyright (c) 1998-2008 Keiju ISHITSUKA(SHL Japan Inc.)
+#   Copyright (c) 2008 Yuki Sonoda (Yugui) <yugui@yugui.jp>
+#
+# Documentation::
+#   Yuki Sonoda
+#
+
+require "singleton"
+require "forwardable"
+
+class Integer
+  # Re-composes a prime factorization and returns the product.
+  #
+  # See Prime#int_from_prime_division for more details.
+  def Integer.from_prime_division(pd)
+    Prime.int_from_prime_division(pd)
+  end
+
+  # Returns the factorization of +self+.
+  #
+  # See Prime#prime_division for more details.
+  def prime_division(generator = Prime::Generator23.new)
+    Prime.prime_division(self, generator)
+  end
+
+  # Returns true if +self+ is a prime number, false for a composite.
+  def prime?
+    Prime.prime?(self)
+  end
+
+  # Iterates the given block over all prime numbers.
+  #
+  # See +Prime+#each for more details.
+  def Integer.each_prime(ubound, &block) # :yields: prime
+    Prime.each(ubound, &block)
+  end
+end
+
+#
+# The set of all prime numbers.
+#
+# == Example
+#
+#   Prime.each(100) do |prime|
+#     p prime  #=> 2, 3, 5, 7, 11, ...., 97
+#   end
+#
+# Prime is Enumerable:
+#
+#   Prime.first 5 # => [2, 3, 5, 7, 11]
+#
+# == Retrieving the instance
+#
+# +Prime+.new is obsolete. Now +Prime+ has the default instance and you can
+# access it as +Prime+.instance.
+#
+# For convenience, each instance method of +Prime+.instance can be accessed
+# as a class method of +Prime+.
+#
+# e.g.
+#   Prime.instance.prime?(2)  #=> true
+#   Prime.prime?(2)           #=> true
+#
+# == Generators
+#
+# A "generator" provides an implementation of enumerating pseudo-prime
+# numbers and it remembers the position of enumeration and upper bound.
+# Furthermore, it is an external iterator of prime enumeration which is
+# compatible with an Enumerator.
+#
+# +Prime+::+PseudoPrimeGenerator+ is the base class for generators.
+# There are few implementations of generator.
+#
+# [+Prime+::+EratosthenesGenerator+]
+#   Uses eratosthenes' sieve.
+# [+Prime+::+TrialDivisionGenerator+]
+#   Uses the trial division method.
+# [+Prime+::+Generator23+]
+#   Generates all positive integers which are not divisible by either 2 or 3.
+#   This sequence is very bad as a pseudo-prime sequence. But this
+#   is faster and uses much less memory than the other generators. So,
+#   it is suitable for factorizing an integer which is not large but
+#   has many prime factors. e.g. for Prime#prime? .
+
+class Prime
+  include Enumerable
+  @the_instance = Prime.new
+
+  # obsolete. Use +Prime+::+instance+ or class methods of +Prime+.
+  def initialize
+    @generator = EratosthenesGenerator.new
+    extend OldCompatibility
+    warn "Prime::new is obsolete. use Prime::instance or class methods of Prime."
+  end
+
+  class << self
+    extend Forwardable
+    include Enumerable
+    # Returns the default instance of Prime.
+    def instance; @the_instance end
+
+    def method_added(method) # :nodoc:
+      (class<< self;self;end).def_delegator :instance, method
+    end
+  end
+
+  # Iterates the given block over all prime numbers.
+  #
+  # == Parameters
+  #
+  # +ubound+::
+  #   Optional. An arbitrary positive number.
+  #   The upper bound of enumeration. The method enumerates
+  #   prime numbers infinitely if +ubound+ is nil.
+  # +generator+::
+  #   Optional. An implementation of pseudo-prime generator.
+  #
+  # == Return value
+  #
+  # An evaluated value of the given block at the last time.
+  # Or an enumerator which is compatible to an +Enumerator+
+  # if no block given.
+  #
+  # == Description
+  #
+  # Calls +block+ once for each prime number, passing the prime as
+  # a parameter.
+  #
+  # +ubound+::
+  #   Upper bound of prime numbers. The iterator stops after it
+  #   yields all prime numbers p <= +ubound+.
+  #
+  # == Note
+  #
+  # +Prime+.+new+ returns an object extended by +Prime+::+OldCompatibility+
+  # in order to be compatible with Ruby 1.8, and +Prime+#each is overwritten
+  # by +Prime+::+OldCompatibility+#+each+.
+  #
+  # +Prime+.+new+ is now obsolete. Use +Prime+.+instance+.+each+ or simply
+  # +Prime+.+each+.
+  def each(ubound = nil, generator = EratosthenesGenerator.new, &block)
+    generator.upper_bound = ubound
+    generator.each(&block)
+  end
+
+
+  # Returns true if +value+ is prime, false for a composite.
+  #
+  # == Parameters
+  #
+  # +value+:: an arbitrary integer to be checked.
+  # +generator+:: optional. A pseudo-prime generator.
+  def prime?(value, generator = Prime::Generator23.new)
+    value = -value if value < 0
+    return false if value < 2
+    for num in generator
+      q,r = value.divmod num
+      return true if q < num
+      return false if r == 0
+    end
+  end
+
+  # Re-composes a prime factorization and returns the product.
+  #
+  # == Parameters
+  # +pd+:: Array of pairs of integers. The each internal
+  #        pair consists of a prime number -- a prime factor --
+  #        and a natural number -- an exponent.
+  #
+  # == Example
+  # For <tt>[[p_1, e_1], [p_2, e_2], ...., [p_n, e_n]]</tt>, it returns:
+  #
+  #   p_1**e_1 * p_2**e_2 * .... * p_n**e_n.
+  #
+  #   Prime.int_from_prime_division([[2,2], [3,1]])  #=> 12
+  def int_from_prime_division(pd)
+    pd.inject(1){|value, (prime, index)|
+      value *= prime**index
+    }
+  end
+
+  # Returns the factorization of +value+.
+  #
+  # == Parameters
+  # +value+:: An arbitrary integer.
+  # +generator+:: Optional. A pseudo-prime generator.
+  #               +generator+.succ must return the next
+  #               pseudo-prime number in the ascending
+  #               order. It must generate all prime numbers,
+  #               but may also generate non prime numbers too.
+  #
+  # === Exceptions
+  # +ZeroDivisionError+:: when +value+ is zero.
+  #
+  # == Example
+  # For an arbitrary integer:
+  #
+  #   n = p_1**e_1 * p_2**e_2 * .... * p_n**e_n,
+  #
+  # prime_division(n) returns:
+  #
+  #   [[p_1, e_1], [p_2, e_2], ...., [p_n, e_n]].
+  #
+  #   Prime.prime_division(12) #=> [[2,2], [3,1]]
+  #
+  def prime_division(value, generator = Prime::Generator23.new)
+    raise ZeroDivisionError if value == 0
+    if value < 0
+      value = -value
+      pv = [[-1, 1]]
+    else
+      pv = []
+    end
+    for prime in generator
+      count = 0
+      while (value1, mod = value.divmod(prime)
+             mod) == 0
+        value = value1
+        count += 1
+      end
+      if count != 0
+        pv.push [prime, count]
+      end
+      break if value1 <= prime
+    end
+    if value > 1
+      pv.push [value, 1]
+    end
+    return pv
+  end
+
+  # An abstract class for enumerating pseudo-prime numbers.
+  #
+  # Concrete subclasses should override succ, next, rewind.
+  class PseudoPrimeGenerator
+    include Enumerable
+
+    def initialize(ubound = nil)
+      @ubound = ubound
+    end
+
+    def upper_bound=(ubound)
+      @ubound = ubound
+    end
+    def upper_bound
+      @ubound
+    end
+
+    # returns the next pseudo-prime number, and move the internal
+    # position forward.
+    #
+    # +PseudoPrimeGenerator+#succ raises +NotImplementedError+.
+    def succ
+      raise NotImplementedError, "need to define `succ'"
+    end
+
+    # alias of +succ+.
+    def next
+      raise NotImplementedError, "need to define `next'"
+    end
+
+    # Rewinds the internal position for enumeration.
+    #
+    # See +Enumerator+#rewind.
+    def rewind
+      raise NotImplementedError, "need to define `rewind'"
+    end
+
+    # Iterates the given block for each prime number.
+    def each(&block)
+      return self.dup unless block
+      if @ubound
+        last_value = nil
+        loop do
+          prime = succ
+          break last_value if prime > @ubound
+          last_value = block.call(prime)
+        end
+      else
+        loop do
+          block.call(succ)
+        end
+      end
+    end
+
+    # see +Enumerator+#with_index.
+    alias with_index each_with_index
+
+    # see +Enumerator+#with_object.
+    def with_object(obj)
+      return enum_for(:with_object) unless block_given?
+      each do |prime|
+        yield prime, obj
+      end
+    end
+  end
+
+  # An implementation of +PseudoPrimeGenerator+.
+  #
+  # Uses +EratosthenesSieve+.
+  class EratosthenesGenerator < PseudoPrimeGenerator
+    def initialize
+      @last_prime_index = -1
+      super
+    end
+
+    def succ
+      @last_prime_index += 1
+      EratosthenesSieve.instance.get_nth_prime(@last_prime_index)
+    end
+    
+    def curr
+      EratosthenesSieve.instance.get_last
+    end
+    
+    def rewind
+      initialize
+    end
+    alias next succ
+  end
+
+  # An implementation of +PseudoPrimeGenerator+ which uses
+  # a prime table generated by trial division.
+  class TrialDivisionGenerator<PseudoPrimeGenerator
+    def initialize
+      @index = -1
+      super
+    end
+
+    def succ
+      TrialDivision.instance[@index += 1]
+    end
+    def rewind
+      initialize
+    end
+    alias next succ
+  end
+
+  # Generates all integers which are greater than 2 and
+  # are not divisible by either 2 or 3.
+  #
+  # This is a pseudo-prime generator, suitable on
+  # checking primality of an integer by brute force
+  # method.
+  class Generator23<PseudoPrimeGenerator
+    def initialize
+      @prime = 1
+      @step = nil
+      super
+    end
+
+    def succ
+      loop do
+        if (@step)
+          @prime += @step
+          @step = 6 - @step
+        else
+          case @prime
+          when 1; @prime = 2
+          when 2; @prime = 3
+          when 3; @prime = 5; @step = 2
+          end
+        end
+        return @prime
+      end
+    end
+    alias next succ
+    def rewind
+      initialize
+    end
+  end
+
+  # Internal use. An implementation of prime table by trial division method.
+  class TrialDivision
+    include Singleton
+
+    def initialize # :nodoc:
+      # These are included as class variables to cache them for later uses.  If memory
+      #   usage is a problem, they can be put in Prime#initialize as instance variables.
+
+      # There must be no primes between @primes[-1] and @next_to_check.
+      @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]
+      # @next_to_check % 6 must be 1.
+      @next_to_check = 103            # @primes[-1] - @primes[-1] % 6 + 7
+      @ulticheck_index = 3            # @primes.index(@primes.reverse.find {|n|
+      #   n < Math.sqrt(@@next_to_check) })
+      @ulticheck_next_squared = 121   # @primes[@ulticheck_index + 1] ** 2
+    end
+
+    # Returns the cached prime numbers.
+    def cache
+      return @primes
+    end
+    alias primes cache
+    alias primes_so_far cache
+
+    # Returns the +index+th prime number.
+    #
+    # +index+ is a 0-based index.
+    def [](index)
+      while index >= @primes.length
+        # Only check for prime factors up to the square root of the potential primes,
+        #   but without the performance hit of an actual square root calculation.
+        if @next_to_check + 4 > @ulticheck_next_squared
+          @ulticheck_index += 1
+          @ulticheck_next_squared = @primes.at(@ulticheck_index + 1) ** 2
+        end
+        # Only check numbers congruent to one and five, modulo six. All others
+
+        #   are divisible by two or three.  This also allows us to skip checking against
+        #   two and three.
+        @primes.push @next_to_check if @primes[2..@ulticheck_index].find {|prime| @next_to_check % prime == 0 }.nil?
+        @next_to_check += 4
+        @primes.push @next_to_check if @primes[2..@ulticheck_index].find {|prime| @next_to_check % prime == 0 }.nil?
+        @next_to_check += 2
+      end
+      return @primes[index]
+    end
+  end
+
+  # Internal use. An implementation of eratosthenes' sieve
+  class EratosthenesSieve
+    include Singleton
+
+    def initialize
+      @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]
+      # @max_checked must be an even number
+      @max_checked = @primes.last + 1
+    end
+    
+    def get_last
+      @primes.last
+    end
+
+    def get_nth_prime(n)
+      compute_primes while @primes.size <= n
+      @primes[n]
+    end
+
+    private
+    def compute_primes
+      # max_segment_size must be an even number
+      max_segment_size = 1e6.to_i
+      max_cached_prime = @primes.last
+      # do not double count primes if #compute_primes is interrupted
+      # by Timeout.timeout
+      @max_checked = max_cached_prime + 1 if max_cached_prime > @max_checked
+
+      segment_min = @max_checked
+      segment_max = [segment_min + max_segment_size, max_cached_prime * 2].min
+      root = Integer(Math.sqrt(segment_max).floor)
+
+      sieving_primes = @primes[1 .. -1].take_while { |prime| prime <= root }
+      offsets = Array.new(sieving_primes.size) do |i|
+        (-(segment_min + 1 + sieving_primes[i]) / 2) % sieving_primes[i]
+      end
+
+      segment = ((segment_min + 1) .. segment_max).step(2).to_a
+      sieving_primes.each_with_index do |prime, index|
+        composite_index = offsets[index]
+        while composite_index < segment.size do
+          segment[composite_index] = nil
+          composite_index += prime
+        end
+      end
+
+      segment.each do |prime|
+        @primes.push prime unless prime.nil?
+      end
+      @max_checked = segment_max
+    end
+  end
+
+  # Provides a +Prime+ object with compatibility to Ruby 1.8 when instantiated via +Prime+.+new+.
+  module OldCompatibility
+    # Returns the next prime number and forwards internal pointer.
+    def succ
+      @generator.succ
+    end
+    alias next succ
+
+    # Overwrites Prime#each.
+    #
+    # Iterates the given block over all prime numbers. Note that enumeration
+    # starts from the current position of internal pointer, not rewound.
+    def each(&block)
+      return @generator.dup unless block_given?
+      loop do
+        yield succ
+      end
+    end
+  end
+end

data/spec/support/regex_prime.rb

@@ -0,0 +1,5 @@
+module RegexPrime
+  def self.is_prime?(n)
+    ('1' * n) !~ /^1?$|^(11+?)\1+$/
+  end
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: prime_lib
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Adit
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: RubyInline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.12.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.12.2
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Write a program that calculates and prints out a multiplication table
+  of the first 10 calculated prime numbers.
+email:
+- a.saxena@email.it
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENCE.txt
+- README.md
+- Rakefile
+- lib/prime_lib.rb
+- lib/prime_lib/decorator/table.rb
+- lib/prime_lib/decorator/table_product.rb
+- lib/prime_lib/generator.rb
+- lib/prime_lib/generator/gen_engine.rb
+- lib/prime_lib/generator/sieve_of_eratosthenes.rb
+- lib/prime_lib/generator/sieve_of_eratosthenes_c.rb
+- lib/prime_lib/generator_product.rb
+- lib/prime_lib/version.rb
+- prime_lib.gemspec
+- spec/decorator/table_spec.rb
+- spec/generator/generator_product_spec.rb
+- spec/generator/generator_spec.rb
+- spec/performance/performance_spec.rb
+- spec/spec_helper.rb
+- spec/support/original_prime.rb
+- spec/support/regex_prime.rb
+homepage: https://bitbucket.org/aditsaxena/prime_lib/src
+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.1.11
+signing_key: 
+specification_version: 4
+summary: The program must run from the command line and print to screen 1 table. Across
+  the top and down the left side should be the 10 primes, and the body of the table
+  should contain the product of multiplying these numbers.
+test_files:
+- spec/decorator/table_spec.rb
+- spec/generator/generator_product_spec.rb
+- spec/generator/generator_spec.rb
+- spec/performance/performance_spec.rb
+- spec/spec_helper.rb
+- spec/support/original_prime.rb
+- spec/support/regex_prime.rb