prime_products 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33ac5620ba1e8f2ad6673b6a0594395d0228b8f79e3b576a0ef333474169bd06
-  data.tar.gz: 9b10d62cc31781174c261eb0496dd270b287613ab1b21aa6184d0913851e8269
+  metadata.gz: 96a7de0da10c68e17d6dcd7e32e3b1aa7e17e340e0eba32537a9796d9316ca5d
+  data.tar.gz: e6c6dd590d1d252ed5d475c3d0af092e20218a1fc3d042a0d31a5f41c751225c
 SHA512:
-  metadata.gz: 11d1a587e00911b5c2199eea91465b6cf88d1159ee1474f0b09f8ae2fac9981dac0b4aedebc851d45b9dfb42ed9ed0b244ca2757102d51881f2e80f5c3b66ed0
-  data.tar.gz: f3f2cd5387c6d78787322fe0629023e7a9eb2f90081362d0d2577023611e25d190bb1cadaf646e8f9f76b2222920934a01c45bd8cfda23c45b50671e82832c5c
+  metadata.gz: 1e45aa1bb267f93246a6b07064331fbcc0c8e773051ad1da973f2a25137bbf35b12fb65faced2577736e2bbe68e2f2031335977dafdf6d4cb8b4473610f2e10a
+  data.tar.gz: 2c7904556a01e57d85d1c178879ca6d4c444348cb9ad74a9747b52ac235b99923b654f8904f5147d7e28108e49fb1bf8ff15bd6f91e7d5d490eccb0f3777dd0b

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# v0.2.0 (26 Nov 2018)
+
+* Use the Sieve of Eratosthenes method to find prime numbers
+
 # v0.1.1 (25 Nov 2018)
 
 * Rename `PrimeProducts::ProductsTable` to `PrimeProducts::MultiplicationTable`

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    prime_products (0.1.1)
+    prime_products (0.2.0)
       hanami-cli (~> 0.3.0)
       immutable-ruby (~> 0.0.3)
       terminal-table (~> 1.8.0)

data/README.md

@@ -47,24 +47,29 @@ It finds the number of primes to use, looking at `ARGV` and defaulting to `CLI::
 
 It then calls `PrimeProducts.generate_table` with the `number_of_primes`, and writes the result to the output,
 
-`PrimeProducts.generate_table` finds the requested number of prime numbers using `PrimeProducts::PrimeNumbers.first`, and then asks `PrimeProducts::MultiplicationTable.generate` to generate a multiplication table from them.
+`PrimeProducts.generate_table` finds the requested number of prime numbers using `PrimeProducts::PrimeNumbers::SieveOfEratosthenes.first`, and then asks `PrimeProducts::MultiplicationTable.generate` to generate a multiplication table from them.
 
-`PrimeProducts::PrimeNumbers.first` uses a simple, naive but sufficiently performant method of finding the primes - see the "Benchmarking" section below - and returns them in an `Immutable::SortedSet` to avoid the danger of accidental mutation.
+`PrimeProducts::PrimeNumbers::SieveOfEratosthenes.first` uses the performant Sieve of Eratosthenes method for finding primes - see the "Benchmarking" section below - and returns them in an `Immutable::SortedSet` to avoid the danger of accidental mutation.
 
 ## Benchmarking
 
-This gem uses a naive method of finding the first *n* primes which does not scale especially well. However, this seems reasonable given that the primes will be displayed on-screen, and so it is unlikely you will want to see a large number at once.
+This gem uses the performant Sieve of Eratosthenes method of finding prime numbers (`PrimeProducts::PrimeNumbers::SieveOfEratosthenes`):
 
-Despite being a naive solution, this is still moderately performant. On my machine:
+* finding the first 10 takes ~0.0001s
+* finding the first 100 takes ~0.0006s
+* finding the first 1000 takes ~0.007s
+* finding the first 10000 takes ~0.1s
 
-* finding the first 10 takes ~0.00004s
-* finding the first 100 takes ~0.001s
-* finding the first 1000 takes ~0.2s
-* finding the first 10000 takes ~31s
+As is evident, it scales well for large numbers of primes.
 
-It is unlikely that you would want a table of more than 1000, which only takes ~0.2 seconds. If we wanted to use these numbers elsewhere, and needed more, then I would optimise this code.
+The gem also includes, but doesn't use, a naive method of generating primes (`PrimeProducts::PrimeNumbers::Naive`). It is much less performant - but __this trade-off here might be worth making for simpler code, given that for the use case of displaying multiplication tables, you would only ever want to generate a relatively small set of prime numbers__:
 
-You can see full benchmark results, comparing the Ruby standard library's implementation (`Prime.first`) to mine, by running `ruby benchmarks/prime_numbers.rb`.
+* finding the first 10 takes ~0.0001s
+* finding the first 100 takes ~0.003s
+* finding the first 1000 takes ~0.35s
+* finding the first 10000 takes ~44s
+
+You can see full benchmark results, comparing the Ruby standard library's implementation (`Prime.first`) to these implementations, by running `ruby benchmarks/prime_numbers.rb`.
 
 ## Development
 

data/benchmarks/prime_numbers.rb

@@ -2,11 +2,13 @@
 
 require "benchmark"
 require "prime"
-require_relative "../lib/prime_products/prime_numbers"
+require_relative "../lib/prime_products/prime_numbers/naive"
+require_relative "../lib/prime_products/prime_numbers/sieve_of_eratosthenes"
 
 Benchmark.bm do |b|
   [10, 100, 1000, 10_000].each do |n|
-    b.report("naive_#{n}") { PrimeProducts::PrimeNumbers.first(n) }
+    b.report("naive_#{n}") { PrimeProducts::PrimeNumbers::Naive.first(n) }
+    b.report("sieve_#{n}") { PrimeProducts::PrimeNumbers::SieveOfEratosthenes.first(n) }
     b.report("stdlib_#{n}") { Prime.first(n) }
   end
 end

data/lib/prime_products.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 require "prime_products/cli"
-require "prime_products/prime_numbers"
+require "prime_products/prime_numbers/naive"
+require "prime_products/prime_numbers/sieve_of_eratosthenes"
 require "prime_products/multiplication_table"
 require "prime_products/version"
 
@@ -24,7 +25,7 @@ module PrimeProducts
   #   prime numbers, starting from 0, you want to the multiplication table of
   # @return [String] the generated table
   def self.generate_table(number_of_primes:)
-    prime_numbers = PrimeNumbers.first(number_of_primes)
+    prime_numbers = PrimeNumbers::Naive.first(number_of_primes)
     MultiplicationTable.generate(prime_numbers)
   end
 end

data/lib/prime_products/prime_numbers/naive.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "immutable"
+
+module PrimeProducts
+  module PrimeNumbers
+    module Naive
+      INFINITY = (1.0 / 0)
+
+      # Finds the first `n` prime numbers using a naive, but easy to understand, method.
+      # Alternative solutions are easy to find and implement.
+      #
+      # However, I am opting to stick with a simpler more friendly option to keep
+      # complexity low, given that __we will be displaying results on a screen__, making
+      # it unlikely that you will show huge quantities.
+      #
+      # Despite being a naive solution, this is still moderately performant. On my
+      # machine:
+      #
+      # * finding the first 10 takes ~0.00004s
+      # * finding the first 100 takes ~0.001s
+      # * finding the first 1000 takes ~0.2s
+      # * finding the first 10000 takes ~31s
+      #
+      # It is unlikely that you would want a table of more than 1000, which only takes
+      # ~0.2 seconds. If we wanted to use these numbers elsewhere, and needed more,
+      # then I would optimise this code.
+      #
+      # @param number_of_primes [Integer] the number of prime numbers, starting from 0,
+      #   you want to find
+      # @return [Immutable::SortedSet<Integer>] the first `n` prime numbers
+      def self.first(number_of_primes)
+        # In Ruby 2.6, you can generate a Range up to infinity with `(2..)` 😍
+        primes = (2..INFINITY).
+          lazy.
+          reject { |i| (2...i).any? { |divisor| (i % divisor).zero? } }.
+          take(number_of_primes).
+          to_a
+
+        Immutable::SortedSet[*primes]
+      end
+    end
+  end
+end

data/lib/prime_products/prime_numbers/sieve_of_eratosthenes.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "immutable"
+
+module PrimeProducts
+  module PrimeNumbers
+    module SieveOfEratosthenes
+      # Finds the first `n` prime numbers using the performant Sieve of Eratosthenes
+      # method.
+      #
+      # See `benchmarks/prime_numbers.rb` - it performs well, but as not as well as
+      # the solution in Ruby's stdlib 😭 But at least it's written in Ruby (not C) and is
+      # fairly easy to understand.
+      #
+      # @param number_of_primes [Integer] the number of prime numbers, starting from 0,
+      #   you want to find
+      # @return [Immutable::SortedSet<Integer>] the first `n` prime numbers
+      def self.first(number_of_primes)
+        estimated_max = number_of_primes * Math.log(number_of_primes * number_of_primes)
+        Immutable::SortedSet[*upto(estimated_max).first(number_of_primes)]
+      end
+
+      # Finds all prime numbers up to `maximum` using the performant Sieve of
+      # Eratosthenes method.
+      #
+      # @param maximum [Integer] the number you want to find primes up to
+      # @return [Array<Integer>] all of the prime numbers up to `maximum`
+      def self.upto(maximum)
+        # All numbers *might* be primes until we start ruling them out
+        primes = (0..maximum).to_a
+
+        # Zero and one aren't considered prime numbers
+        primes[0] = primes[1] = nil
+
+        primes.each do |n|
+          # Skip if this number has already been removed when stepping through
+          # multiples
+          next unless n
+
+          break if n * n > maximum
+
+          # Remove multiples of the number we're looking at - they're not primes
+          (n * n).step(maximum, n) { |i| primes[i] = nil }
+        end
+
+        primes.compact
+      end
+    end
+  end
+end

data/lib/prime_products/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PrimeProducts
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prime_products
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Tim Rogers
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-25 00:00:00.000000000 Z
+date: 2018-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hanami-cli
@@ -161,7 +161,8 @@ files:
 - lib/prime_products.rb
 - lib/prime_products/cli.rb
 - lib/prime_products/multiplication_table.rb
-- lib/prime_products/prime_numbers.rb
+- lib/prime_products/prime_numbers/naive.rb
+- lib/prime_products/prime_numbers/sieve_of_eratosthenes.rb
 - lib/prime_products/version.rb
 - prime_products.gemspec
 homepage: 

data/lib/prime_products/prime_numbers.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require "immutable"
-
-module PrimeProducts
-  module PrimeNumbers
-    INFINITY = (1.0 / 0)
-
-    # Finds the first `n` prime numbers using a naive, but easy to understand, method.
-    # Alternative solutions are easy to find and implement.
-    #
-    # However, I am opting to stick with a simpler more friendly option to keep
-    # complexity low, given that __we will be displaying results on a screen__, making it
-    # unlikely that you will show huge quantities.
-    #
-    # Despite being a naive solution, this is still moderately performant. On my machine:
-    #
-    # * finding the first 10 takes ~0.00004s
-    # * finding the first 100 takes ~0.001s
-    # * finding the first 1000 takes ~0.2s
-    # * finding the first 10000 takes ~31s
-    #
-    # It is unlikely that you would want a table of more than 1000, which only takes
-    # ~0.2 seconds. If we wanted to use these numbers elsewhere, and needed more, then I
-    # would optimise this code.
-    #
-    # @param n [Integer] the number of prime numbers, starting from 0, you want to find
-    # @return [Immutable::SortedSet<Integer>] the first `n` prime numbers
-    def self.first(number_of_primes)
-      # In Ruby 2.6, you can generate a Range up to infinity with `(2..)` 😍
-      primes = (2..INFINITY).
-        lazy.
-        reject { |i| (2...i).any? { |divisor| (i % divisor).zero? } }.
-        take(number_of_primes).
-        to_a
-
-      Immutable::SortedSet[*primes]
-    end
-  end
-end