prime_multiplication_table 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: be3fd8276121c35cd3bf8f27e68e130902b7fee2
+  data.tar.gz: 71e1a2188bc8f8f0ab2335eac253825a54c1a11a
+SHA512:
+  metadata.gz: 82b0212d5ef41ddd16ce8a9912ade4f4a3f2e25532f717aa7054b96028b6b2f8f8af0581268b82e3f675554f13e8267399e2e2a6e543ab4dd660fbdc1ea667f5
+  data.tar.gz: 2a7ee9b6966c7dcbdd127b771abe79b6ee80d523a38e3edb955d8c1c83779183da21d537667cb48baa092ef9102848f8572af8ce96f051d64744de0778c65677

data/.gitignore

@@ -0,0 +1,3 @@
+# Created by .ignore support plugin (hsz.mobi)
+.idea
+.ruby-*

data/.rubocop.yml

@@ -0,0 +1,19 @@
+# See full list of defaults here: https://github.com/bbatsov/rubocop/blob/master/config/default.yml
+# To see all cops used see here: https://github.com/bbatsov/rubocop/blob/master/config/enabled.yml
+
+AllCops:
+  TargetRubyVersion: 2.3
+  DisplayCopNames: true
+
+LineLength:
+  Max: 120
+
+Style/OpMethod:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Metrics/BlockLength:
+  Exclude:
+    - '**/*_spec.rb'

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in prime_multiplication_table.gemspec
+gemspec
+
+group :test do
+  gem 'rspec', require: false
+end
+
+group :development do
+  gem 'rubocop'
+end

data/Gemfile.lock

@@ -0,0 +1,48 @@
+PATH
+  remote: .
+  specs:
+    prime_multiplication_table (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.3.0)
+    diff-lcs (1.3)
+    parser (2.4.0.0)
+      ast (~> 2.2)
+    powerpack (0.1.1)
+    rainbow (2.2.2)
+      rake
+    rake (12.0.0)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.4)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    rubocop (0.48.1)
+      parser (>= 2.3.3.1, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.8.1)
+    unicode-display_width (1.2.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  prime_multiplication_table!
+  rspec
+  rubocop
+
+BUNDLED WITH
+   1.13.6

data/README.md

@@ -0,0 +1,36 @@
+### Installation
+
+```bash
+gem install prime_multiplication_table
+```
+
+### Usage
+
+```bash
+$ prime_multiplication_table
+prime_multiplication_table (version: 0.1.0)
+    2  3   5   7  11  13  17  19  23  29
+ 2  4  6  10  14  22  26  34  38  46  58
+ 3  6  9  15  21  33  39  51  57  69  87
+ 5 10 15  25  35  55  65  85  95 115 145
+ 7 14 21  35  49  77  91 119 133 161 203
+11 22 33  55  77 121 143 187 209 253 319
+13 26 39  65  91 143 169 221 247 299 377
+17 34 51  85 119 187 221 289 323 391 493
+19 38 57  95 133 209 247 323 361 437 551
+23 46 69 115 161 253 299 391 437 529 667
+29 58 87 145 203 319 377 493 551 667 841
+
+
+$ prime_multiplication_table 1
+prime_multiplication_table (version: 0.1.0)
+  2
+2 4
+
+
+$ prime_multiplication_table 2
+prime_multiplication_table (version: 0.1.0)
+  2 3
+2 4 6
+3 6 9
+```

data/bin/prime_multiplication_table

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'prime_multiplication_table'
+require 'prime_multiplication_table_cli'
+
+PrimeMultiplicationTableCLI.run(ARGV)

data/lib/prime_multiplication_table.rb

@@ -0,0 +1,11 @@
+require 'forwardable'
+
+# This is main namespace for the library.
+module PrimeMultiplicationTable
+end
+
+require 'prime_multiplication_table/version'
+require 'prime_multiplication_table/cache'
+require 'prime_multiplication_table/atkin_sieve'
+require 'prime_multiplication_table/prime'
+require 'prime_multiplication_table/renderer'

data/lib/prime_multiplication_table/atkin_sieve.rb

@@ -0,0 +1,85 @@
+module PrimeMultiplicationTable
+  # AtkinSieve contains implementation of atkin algorithm to find prime numbers.
+  module AtkinSieve
+    def nth_prime(n)
+      return Cache[n] if Cache[n]
+      Cache.primes = compute_primes(n)
+      Cache[n]
+    end
+
+    private
+
+    def compute_primes(count)
+      return Cache.primes if Cache.size > count
+      sieve_size = compute_sieve_size(count)
+      atkin_sieve(sieve_size).each_with_index.map { |v, p| p if v }.compact
+    end
+
+    # TODO: 52 should be replaced with algorithm to find range which cover expected count of prime numbers
+    #
+    # As we know  the range 1..10**23 contains 1_925_320_391_606_803_968_923 prime numbers
+    #   (so, the range contains 1.92 % on prime numbers)
+    # to find 100 prime numbers we need to create sieve 100 * (100 / 1.92) or 100 * 52
+    def compute_sieve_size(count)
+      count * 52
+    end
+
+    def atkin_sieve(sieve_size)
+      sieve = init_sieve
+      filter_sieve(sieve, sieve_size)
+      finalize_sieve(sieve, sieve_size)
+      sieve
+    end
+
+    def init_sieve
+      # 0,  1,   2,    3
+      [nil, nil, true, true]
+    end
+
+    def filter_sieve(sieve, sieve_size)
+      sieve_size_sqrt = Math.sqrt(sieve_size).floor
+
+      (1..sieve_size_sqrt).each do |x|
+        (1..sieve_size_sqrt).each do |y|
+          filter_sieve_iteration(sieve, sieve_size, x, y)
+        end
+      end
+    end
+
+    def finalize_sieve(sieve, sieve_size)
+      sieve_size_sqrt = Math.sqrt(sieve_size).floor
+
+      (5..sieve_size_sqrt).each do |n|
+        next if Cache[n] || !sieve[n]
+        step = n**2
+        (step..sieve_size).step(step) do |not_prime|
+          sieve[not_prime] = false
+        end
+      end
+    end
+
+    def filter_sieve_iteration(sieve, sieve_size, x, y)
+      x2 = x**2
+      y2 = y**2
+
+      apply_first_filter(sieve, sieve_size, x2, y2)
+      apply_second_filter(sieve, sieve_size, x2, y2)
+      apply_third_filter(sieve, sieve_size, x2, y2) if x > y
+    end
+
+    def apply_first_filter(sieve, sieve_size, x2, y2)
+      n = x2 * 4 + y2
+      sieve[n] = !sieve[n] if n <= sieve_size && (n % 12 == 1 || n % 12 == 5)
+    end
+
+    def apply_second_filter(sieve, sieve_size, x2, y2)
+      n = x2 * 4 + y2 - x2
+      sieve[n] = !sieve[n] if n <= sieve_size && n % 12 == 7
+    end
+
+    def apply_third_filter(sieve, sieve_size, x2, y2)
+      n = x2 * 4 + y2 - x2 - 2 * y2
+      sieve[n] = !sieve[n] if n <= sieve_size && n % 12 == 11
+    end
+  end
+end

data/lib/prime_multiplication_table/cache.rb

@@ -0,0 +1,15 @@
+module PrimeMultiplicationTable
+  # Cache contains already calculated prime numbers.
+  module Cache
+    class << self
+      extend Forwardable
+      attr_writer :primes
+
+      def_delegators :primes, :[], :[]=, :last, :size
+
+      def primes
+        @primes ||= [2, 3]
+      end
+    end
+  end
+end

data/lib/prime_multiplication_table/prime.rb

@@ -0,0 +1,22 @@
+module PrimeMultiplicationTable
+  # Prime contains implementation of comparable prime number.
+  class Prime
+    include Comparable
+    include AtkinSieve
+
+    attr_reader :value
+
+    def initialize(position)
+      @position = position
+      @value = nth_prime(@position)
+    end
+
+    def succ
+      self.class.new(@position + 1)
+    end
+
+    def <=>(other)
+      @value <=> other.value
+    end
+  end
+end

data/lib/prime_multiplication_table/renderer.rb

@@ -0,0 +1,31 @@
+module PrimeMultiplicationTable
+  # Renderer contains implementation of table renderer functionality.
+  class Renderer
+    def initialize(primes_array)
+      @primes_array = primes_array
+    end
+
+    def render
+      matrix.map { |r| render_row(r) }.join("\n")
+    end
+
+    private
+
+    def render_row(row_array)
+      row_array.each_with_index.map { |c, i| c.to_s.rjust(cell_size(i)) }.join(' ')
+    end
+
+    def matrix
+      @matrix ||= [[nil] + @primes_array] + @primes_array.map do |prime_x|
+        @primes_array.each_with_index.each_with_object([]) do |(prime_y, index), result|
+          result << prime_x if index.to_i.zero?
+          result << prime_x * prime_y
+        end
+      end
+    end
+
+    def cell_size(cell_index)
+      matrix.last[cell_index].to_s.size
+    end
+  end
+end

data/lib/prime_multiplication_table/version.rb

@@ -0,0 +1,3 @@
+module PrimeMultiplicationTable
+  VERSION = '0.1.0'.freeze
+end

data/lib/prime_multiplication_table_cli.rb

@@ -0,0 +1,19 @@
+# Command line interface of prime_multiplication_table gem.
+module PrimeMultiplicationTableCLI
+  DEFAULT_TABLE_SIZE = 10
+
+  class << self
+    def run(args)
+      puts "prime_multiplication_table (version: #{PrimeMultiplicationTable::VERSION})"
+      size = parse_table_size_argument(args)
+      prime_class = PrimeMultiplicationTable::Prime
+      array = (prime_class.new(0)...prime_class.new(size)).map(&:value)
+      puts PrimeMultiplicationTable::Renderer.new(array).render
+    end
+
+    def parse_table_size_argument(args)
+      size = args.first.to_i
+      size.positive? ? size : DEFAULT_TABLE_SIZE
+    end
+  end
+end

data/prime_multiplication_table.gemspec

@@ -0,0 +1,18 @@
+require File.expand_path('../lib/prime_multiplication_table/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = 'prime_multiplication_table'
+  gem.version       = PrimeMultiplicationTable::VERSION
+  gem.date          = '2017-05-08'
+  gem.summary       = 'Prime multiplication table printer'
+  gem.description   = 'Ruby gem for printing prime multiplication tables'
+  gem.authors       = ['Konstantin Lynda']
+  gem.email         = 'knlynda@gmail.com'
+  gem.files         = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
+  gem.test_files    = gem.files.grep(%r{^spec/})
+  gem.require_paths = ['lib']
+  gem.bindir        = 'bin'
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  gem.homepage      = 'http://rubygems.org/gems/prime_multiplication_table'
+  gem.license       = 'MIT'
+end

data/spec/lib/prime_multiplication_table/cache_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+RSpec.describe PrimeMultiplicationTable::Cache do
+  it { is_expected.to respond_to :primes, :primes=, :[], :[]=, :last, :size }
+
+  describe '.primes' do
+    subject { described_class.primes }
+
+    it { is_expected.to eql [2, 3] }
+  end
+end

data/spec/lib/prime_multiplication_table/prime_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+RSpec.describe PrimeMultiplicationTable::Prime do
+  describe '#succ' do
+    subject { described_class.new(position) }
+
+    context 'when position is zero' do
+      let(:position) { 0 }
+      it { expect(subject.value).to eql 2 }
+    end
+
+    context 'when position is 1' do
+      let(:position) { 1 }
+      it { expect(subject.value).to eql 3 }
+    end
+
+    context 'when position is 499' do
+      let(:position) { 499 }
+      it { expect(subject.value).to eql 3571 }
+    end
+
+    context 'when position is -1' do
+      let(:position) { -1 }
+      it { expect(subject.value).to eql PrimeMultiplicationTable::Cache[-1] }
+    end
+
+    context 'when position is -500_000' do
+      let(:position) { -500_000 }
+      it { expect(subject.value).to be_nil }
+    end
+  end
+
+  describe '#nth_prime' do
+    subject { described_class.new(position).nth_prime(new_position) }
+
+    context 'when position is zero and new_position is 1' do
+      let(:position) { 0 }
+      let(:new_position) { 1 }
+
+      it { is_expected.to eql 3 }
+    end
+
+    context 'when position is zero and new_position is zero' do
+      let(:position) { 0 }
+      let(:new_position) { 0 }
+
+      it { is_expected.to eql 2 }
+    end
+
+    context 'when position is zero and new_position is 499' do
+      let(:position) { 0 }
+      let(:new_position) { 499 }
+
+      it { is_expected.to eql 3571 }
+    end
+
+    context 'when position is zero and new_position is -1' do
+      let(:position) { 0 }
+      let(:new_position) { -1 }
+
+      it { is_expected.to eql PrimeMultiplicationTable::Cache[-1] }
+    end
+
+    context 'when position is zero and new_position is -500_000' do
+      let(:position) { 0 }
+      let(:new_position) { -500_000 }
+
+      it { is_expected.to be_nil }
+    end
+  end
+end

data/spec/lib/prime_multiplication_table/renderer_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+RSpec.describe PrimeMultiplicationTable::Renderer do
+  describe '#render' do
+    subject { described_class.new(table_basis).render }
+
+    context 'when table_basis is empty' do
+      let(:table_basis) { [] }
+      it { is_expected.to be_empty }
+    end
+
+    context 'when table_basis is not empty' do
+      let(:table_basis) { [1, 2, 3] }
+      it { is_expected.to eql "  1 2 3\n1 1 2 3\n2 2 4 6\n3 3 6 9" }
+    end
+
+    context 'when table_basis includes big and small numbers' do
+      let(:table_basis) { [11, 2, 33] }
+      it { is_expected.to eql "    11  2   33\n11 121 22  363\n 2  22  4   66\n33 363 66 1089" }
+    end
+  end
+end

data/spec/prime_multiplication_table_cli_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+RSpec.describe PrimeMultiplicationTableCLI do
+  describe '.run' do
+    subject(:run) { described_class.run(args) }
+    let(:renderer) { double }
+
+    before do
+      expect(PrimeMultiplicationTable::Renderer).to receive(:new).with(renderer_args).and_return(renderer)
+      expect(renderer).to receive(:render)
+    end
+
+    context 'when args is [0]' do
+      let(:args) { [0] }
+      let(:renderer_args) { [2, 3, 5, 7, 11, 13, 17, 19, 23, 29] }
+
+      it { run }
+    end
+
+    context 'when args is [1]' do
+      let(:args) { [1] }
+      let(:renderer_args) { [2] }
+
+      it { run }
+    end
+
+    context 'when args is [1]' do
+      let(:args) { [1] }
+      let(:renderer_args) { [2] }
+
+      it { run }
+    end
+
+    context 'when args is [5]' do
+      let(:args) { [5] }
+      let(:renderer_args) { [2, 3, 5, 7, 11] }
+
+      it { run }
+    end
+
+    context 'when args is [-1]' do
+      let(:args) { [-1] }
+      let(:renderer_args) { [2, 3, 5, 7, 11, 13, 17, 19, 23, 29] }
+
+      it { run }
+    end
+
+    context 'when args is ["one"]' do
+      let(:args) { ['one'] }
+      let(:renderer_args) { [2, 3, 5, 7, 11, 13, 17, 19, 23, 29] }
+
+      it { run }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'prime_multiplication_table'
+require 'prime_multiplication_table_cli'
+
+RSpec.configure(&:disable_monkey_patching!)

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: prime_multiplication_table
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Konstantin Lynda
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-05-08 00:00:00.000000000 Z
+dependencies: []
+description: Ruby gem for printing prime multiplication tables
+email: knlynda@gmail.com
+executables:
+- prime_multiplication_table
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- README.md
+- bin/prime_multiplication_table
+- lib/prime_multiplication_table.rb
+- lib/prime_multiplication_table/atkin_sieve.rb
+- lib/prime_multiplication_table/cache.rb
+- lib/prime_multiplication_table/prime.rb
+- lib/prime_multiplication_table/renderer.rb
+- lib/prime_multiplication_table/version.rb
+- lib/prime_multiplication_table_cli.rb
+- prime_multiplication_table.gemspec
+- spec/lib/prime_multiplication_table/cache_spec.rb
+- spec/lib/prime_multiplication_table/prime_spec.rb
+- spec/lib/prime_multiplication_table/renderer_spec.rb
+- spec/prime_multiplication_table_cli_spec.rb
+- spec/spec_helper.rb
+homepage: http://rubygems.org/gems/prime_multiplication_table
+licenses:
+- MIT
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Prime multiplication table printer
+test_files:
+- spec/lib/prime_multiplication_table/cache_spec.rb
+- spec/lib/prime_multiplication_table/prime_spec.rb
+- spec/lib/prime_multiplication_table/renderer_spec.rb
+- spec/prime_multiplication_table_cli_spec.rb
+- spec/spec_helper.rb