primetable 0.0.1 → 0.2.0

data/lib/primetable.rb

@@ -1,5 +1,138 @@
+# Not sure why this is here. I'll have to experiment with taking it out.
 require "primetable/version"
 
-module PrimeTable
-  
-end
+# This is needed for load_primes method, which loads data from a file.
+require "yaml"
+
+# I'll probably remove this later, but it's my interim table display solution.
+require "awesome_print"
+
+# It's a pretty simple program. I considered making multiple classes, but it's not necessary.
+class PrimeTable
+
+  # We're going to want to get and set things from inside multiple methods, so...
+  attr_accessor :primes, :table
+
+  def initialize(first=1, count=10, prime_method=:calc, suppress_output=false)
+
+    # This is only for testing, I'm unlikely to implement a command-line flag for this
+    unless suppress_output
+
+      puts "PrimeTable is running..."
+    end
+
+    # Ye olde instance variables
+    @primes = init_primes(:load,first,count)
+    @table = build_data(@primes)
+
+    # I added this suppress_output so I could run certain tests without a huge, admittly
+    # ugly, table clobbering my nice green passing specs
+    unless suppress_output
+      display_table(@table)
+    end
+
+  end # def initialize()
+
+  # One way or another, we need to get an array of consecutive prime numbers.
+  def init_primes(prime_method, first, count)
+
+    # Of course, we calculate the primes by default. But having three methods is not only
+    # fancy; it's also comes in handy for testing that our calculated values are correct.
+    case prime_method
+      when :fast # Shaves off about between 10 and 40 milliseconds vs. the :load method
+        [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
+
+      when :load # Using precalculated values saves us a lot of time vs. the :calc method
+        load_primes(first,count)
+      when :calc # The slowest, but presumably preferred, method in our arsenal
+        calc_primes(first,count)
+    end # case prime_method
+
+  end # def init_primes()
+
+  # Calculates the primes using basic math. This can be slow for higher primes or higher counts.
+  # TODO: Include note on computational complexity here: O(n*sqrt(n)), I think
+  # TODO: Include note on average run time using this method.
+  def calc_primes(first, count)
+
+  end
+
+  # Loads precalculated primes from a data file. The file is formatted with 10 primes per line.
+  # Each line is enclosed in square brackets, and the primes are comma-delimited. Thus, it's
+  # trivial to read each line in as an array of ten primes. Please note that this file is 995K
+
+  # and contains 13413 lines. You don't want to just slurp this file. That would be rude. Instead
+
+  # we read lines one at a time and only keep what we need. Also note the highest prime in this
+  # file is currently 1999993, although conceivably we could use the :calc method and extend it.
+  def load_primes(first, count)
+
+    # Again, we only have the first 134128 primes in here right now
+    if (first + count) > 134128
+      throw "We only have the first 134128 primes in the data file right now. Please pass -c to use calculated primes."
+    end
+
+    # An array to keep our prime numbers in, right?
+    primes = []
+
+    # Because there are ten primes on each line, we can get the line number we're looking for by
+    # dividing the indices we want by 10 and rounding down for the bottom of our range and up for
+
+    # the top. It's not immediately intuitive why we might want to do this, but it's because:
+    #   1) We don't want to slurp the whole file...what if the file was even larger? Not cool.
+
+    #   2) IO.readlines gets the file one line at a time, so we need a line number, not an index.
+
+    first_line = (first/10).floor
+    last_line = ((first+count)/10).ceil
+
+    # Here we read in the file one line at a time. Yes I looked for a faster way. Try :fast (-f).
+    IO.readlines("data/prime.dat").each_with_index{|line,ln|
+
+      # When we find the lines we want, we concatenate them into a single array. We get extra.
+      if (ln >= first_line and ln <= last_line)
+         primes.concat(YAML::load(line))
+      end
+    }
+
+    # The extra is trimmed off in this step. We know what we want. Just this, thanks!
+    start = first - (first_line*10) - 1
+    return primes.slice!(start,count)
+
+  end
+
+  def build_data(primes)
+
+    # To make this code simpler we act as if our first prime is 1 so that the matrix includes
+    # our header row and column of primes (multiplied by 1)...we remove the corner 1 later
+    primes.unshift(1)
+
+    # An empty two-dimensional array to act as the data model for our table
+    table = Array.new(primes.length) { Array.new(primes.length) }
+
+    # We populate the array-of-arrays with the products-of-primes ;-)
+    primes.each_with_index{|outerprime,i|
+      primes.each_with_index{|innerprime,y|
+        table[i][y] = outerprime*innerprime
+      }
+    }
+
+    # Here we remove the corner 1 which was added as a side-effect of the matrix generation
+    primes.shift(1)
+    table[0][0] = nil
+
+    # And send the table data to display (or, in theory, whoever called us)
+    return table
+
+  end
+
+  # The plan is to use Formatador to make this display nicely. For now, I'm just dumping the data,
+  # and making it slightly less lame with awesome_print.
+  def display_table(table)
+
+    # Not much to see here. But I expect to be able to justify a comment soon enough.
+    ap table
+
+  end
+
+end

data/lib/primetable/version.rb

@@ -1,3 +1,3 @@
-module PrimeTable
-  VERSION = "0.0.1"
+class PrimeTable
+  VERSION = "0.2.0"
 end

data/lib/timer.rb

@@ -0,0 +1,28 @@
+class Timer
+
+  def self.timer(&block)
+    start_time = Time.now
+    result = block.call
+    end_time = Time.now
+    @time_taken = (end_time - start_time) * 1000
+    result
+  end
+
+  def self.humanize ms
+    [[1000, :ms], [60, :secs], [60, :mins], [24, :hrs], [365, :days], [10000, :yrs]].map{ |count, name|
+      if ms > 0
+        ms, n = ms.divmod(count)
+        "#{n.to_i} #{name}"
+      end
+    }.compact.reverse.join(' ')
+  end
+
+  def self.elapsedTime
+   humanize @time_taken
+  end
+
+  def self.time()
+    elapsedTime
+  end
+
+end

data/primetable.gemspec

@@ -21,4 +21,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
+  spec.add_development_dependency "awesome_print"
 end

data/spec/primetable_spec.rb

@@ -1,8 +1,65 @@
 require 'spec_helper'
 
 describe PrimeTable do
+  before(:all) do
+    @expected_execution_output = "PrimeTable is running...\n"
+    @expected_time_output = "ms"
+    @expected_version_output = PrimeTable::VERSION
+    @expected_help_output = "Common options:
+    -t, --time                       Display run time
+    -h, --help                       Show this message
+    -v, --version                    Show version"
+    @expected_first_ten_primes = [2,3,5,7,11,13,17,19,23,29]
+    @expected_table_with_first_ten_primes = [[nil,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]]
+  end
   it 'has a version number' do
     expect(PrimeTable::VERSION).not_to be nil
   end
-  
+  it 'executes when called on the command line' do
+    expect(`primetable`).to include("PrimeTable is running...\n")
+  end
+  it 'executes *and* prints out a run time when passed -t or --time' do
+    execution_output = `primetable -t`
+    expect(execution_output).to include(@expected_execution_output)
+    expect(execution_output).to include(@expected_time_output)
+    execution_output = `primetable --time`
+    expect(execution_output).to include(@expected_execution_output)
+    expect(execution_output).to include(@expected_time_output)
+  end  
+  it 'prints out the version number when passed -v or --version' do
+    expect(`primetable -v`).to include(@expected_version_output)
+  end
+  it 'executes *and* prints out a run time *and* prints out the version number when passed both -t and -v arguments' do
+    execution_output = `primetable -tv`
+    expect(execution_output).to include(@expected_execution_output)
+    expect(execution_output).to include(@expected_time_output)
+    expect(execution_output).to include(@expected_version_output)
+  end
+  it 'executes *and* prints out a run time *and* prints out the version number when passed both --time and --version arguments' do
+    execution_output = `primetable -tv`
+    expect(execution_output).to include(@expected_execution_output)
+    expect(execution_output).to include(@expected_time_output)
+    expect(execution_output).to include(@expected_version_output)
+  end
+  it 'prints out usage details when passed -h or --help' do
+    execution_output = `primetable -h`
+    expect(execution_output).to include(@expected_help_output)
+    execution_output = `primetable --help`
+    expect(execution_output).to include(@expected_help_output)
+  end
+  it "has the right data when we run it with :load" do
+    test_instance = PrimeTable.new(1,10,:load,true)
+    expect(test_instance.primes).to eq(@expected_first_ten_primes)
+    expect(test_instance.table).to eq(@expected_table_with_first_ten_primes)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: primetable
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Day Davis Waterbury
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-19 00:00:00.000000000 Z
+date: 2015-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,11 +52,26 @@ dependencies:
     - - ">="
       - !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: Displays the products of N primes in a table format. Optionally uses
   generated primes or precalculated.
 email:
 - day.waterbury@gmail.com
-executables: []
+executables:
+- primetable
 extensions: []
 extra_rdoc_files: []
 files:
@@ -67,8 +82,11 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/primetable
+- data/prime.dat
 - lib/primetable.rb
 - lib/primetable/version.rb
+- lib/timer.rb
 - primetable.gemspec
 - spec/primetable_spec.rb
 - spec/spec_helper.rb