primetable 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c24c22e449b7f2120749f470e461236d7ed95aac
-  data.tar.gz: 331b1e2a79c976356115ac1e5fd6528bb6674bd6
+  metadata.gz: f529942f1f2d716e11f9609269616f35df535a74
+  data.tar.gz: 7edabbe0d6900024c84ea305916e1f0febab1631
 SHA512:
-  metadata.gz: 427232225c8ca84f6dcd02be2e15629d5bf8295709b19675567b368dc84ad76f600deaa135096ed5bdf7ffbe5b0c3c0fd98ea1f030ff2c4d26d08637943fbb63
-  data.tar.gz: 25911f922666fa41e124cc955e562b36df10b74b3fc64256d8efd291bdba9cafcb155809dd1ba93c96e72adf55cc12138a5e9bcbf0d4bb4f47c1bc5a32ecdffa
+  metadata.gz: 00104a159da8a03925648e49f8ef36ab92d00e1eb76cded4d178c1b2847f26bc00ae00e2650a5c6aa1b8050c229213f6953268a6521ecbef23c558e96588093a
+  data.tar.gz: bb899a0aa5e6d5d646e23604b07b8dae355f2f440e385041caf602ba859175546349a64ecc4c4e337b339e25f0c65abf9fc95028599349d11b54601ede89355f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    primetable (0.4.0)
+    primetable (1.0.0)
       formatador (~> 0.2, >= 0.2.5)
       therubyracer (~> 0.12, >= 0.12.2)
 

data/README.md

@@ -13,11 +13,12 @@
     Usage: primetable [options]
     
     Specific options:
-        --code CODE                      Select encoding
-                                           (jis,sjis,iso-2022-jp,shift_jis,euc-jp,utf8,binary)
+        -f F                             First prime (default is 2, limit is 2000003 w/ -m load|fast, 9007199254740727 w/ -m calc)
+        -n N                             Number of primes for which you wish to generate a table
+        -m, --method METHOD              Select method of generating primes (fast|load|calc) (default is 'calc')
+        -t, --time                       Display run time
     
     Common options:
-        -t, --time                       Display run time
         -h, --help                       Show this message
         -v, --version                    Show version
 

data/bin/primetable

@@ -19,7 +19,7 @@ class OptParse
     # The options specified on the command line will be collected in *options*.
     # We set default values here.
     options = OpenStruct.new
-    options.flags = OpenStruct.new({time: false, n: 0, help: false, version: false})
+    options.flags = OpenStruct.new({f: 2, n: 10, prime_method: :calc, time: false, version: false, help: false})
     options.encoding = "utf8"
 
     opt_parser = OptionParser.new do |opts|
@@ -27,50 +27,39 @@ class OptParse
 
       opts.separator ""
       opts.separator "Specific options:"
-      
-      # This will add a display of the run time to the usual output.
-      opts.on_tail("-t", "--time", "Display run time") do
-        options.flags.time = true
-      end
-  
-      # I think we can agree it's wise to limit the starting prime index to no more than 9999999999
-      opts.on("-f F", Float, "First prime (where count starts). E.g. Default is 2 for the 1st prime.") do |f|
-        if f.to_i <= 9999999999
-          options.flags.f = f.to_i
-        end
+
+      # The first prime
+      opts.on("-f F", Float, "First prime (default is 2, limit is 2000003 w/ -m load|fast, 9007199254740727 w/ -m calc)") do |f|
+        options.flags.f = f.to_i
       end
-      
-      # I'm limiting the count arbitraily to 99 here, and silently ignoring requests for counts of 100 or higher
+
+      # Number of primes
       opts.on("-n N", Float, "Number of primes for which you wish to generate a table") do |n|
-        if n.to_i < 99
-          options.flags.n = n.to_i
-        end
+        options.flags.n = n.to_i
       end
-      
-      # Likewise, here I'm limiting the count arbitraily to 99
-      opts.on(/[0-9]{1,2}/, "Number of primes for which you wish to generate a table") do |n|
+
+      # We can also pass the number of primes as N without a swiitch
+      opts.on(/[0-9]{1,2}/) do |n|
         options.flags.n = n.to_i
       end
-      
-      # And finally, here as well I'm limiting the count arbitraily to 99...honestly we can't reasonably display > 20
-      # I'm also limiting us to starting prime indices 10 digits or less (as above)
-      opts.on(/[0-9]{1,10},[0-9]{1,2}/, "Number of primes for which you wish to generate a table") do |fn|
+
+      # We can pass the first prime and the number of primes as F,N without a switch
+      opts.on(/[0-9]{1,10},[0-9]{1,2}/) do |fn|
         options.flags.f = fn.split(",")[0].to_i
         options.flags.n = fn.split(",")[1].to_i
       end
 
-      opts.on("-m METHOD", "--method METHOD", METHODS, "Select method of generating primes") do |method|
+      # Specify a method of generating primes, the options are fast, load, and calc (default is calc)
+      opts.on("-m METHOD", "--method METHOD", "Select method of generating primes (fast|load|calc) (default is 'calc')") do |method|
         options.flags.prime_method = method.to_sym
       end
 
-      # Keyword completion.  We are specifying a specific set of arguments (CODES and CODE_ALIASES - notice the
-      # latter is a Hash), and the user may provide the shortest unambiguous text.
-      code_list = (CODE_ALIASES.keys + CODES).join(',')
-      opts.on("--code CODE", CODES, CODE_ALIASES, "Select encoding",
-              "  (#{code_list})") do |encoding|
-        options.encoding = encoding
+      # Add a display of the run time to the usual output.
+      opts.on("-t", "--time", "Display run time") do
+        options.flags.time = true
       end
 
+      # For display of the usage instructions
       opts.separator ""
       opts.separator "Common options:"
 
@@ -87,9 +76,9 @@ class OptParse
 
     opt_parser.parse!(args)
     options
-  end  # parse()
+  end # parse()
 
-end  # class OptParse
+end # class OptParse
 
 # copy ARGV so I can check it later after it's gone
 ARGS = ARGV.clone
@@ -97,62 +86,130 @@ ARGS = ARGV.clone
 # Parse the options and behave accordingly...this code alters, er, empties ARGV
 options = OptParse.parse(ARGV)
 
-# Default behavior if no options are passed
-if ARGS.length == 0
-  PrimeTable.new()
+# We might have feedback to display later
+messages = []
+
+# Input limitations on first prime (F)
+if options.flags.f > 2000003 and options.flags.prime_method != :calc
+  # I'm limiting us to starting primes of 2000003 or less if we're not using :calc
+  # This is because the file and the constant only have a certain number of primes
+  options.flags.f = 2000003
+  messages.push("Warning! The first prime (F) is limited to 2000003 w/ -m load|fast. Try -m calc for F up to 9007199254740727.")
+elsif options.flags.f > 9007199254740727 and options.flags.prime_method == :calc
+  # And I'm limiting us to starting primes of 9007199254740727 or less if we are using :calc because JS will time out
+  options.flags.f = 9007199254740727
+  messages.push("Warning! The first prime (F) is limited to 9007199254740727 w/ -m calc. JS times out after 7 secs.")
 end
 
-# We default to calculating the primes on the fly
-if options.flags.prime_method === nil
-  options.flags.prime_method = :calc
+# I'm limiting the table display (N) based on what will fit on the screen here.
+# I'm sure there's a crafty equation here that would put this all on one line...but, this will do for now.
+# TODO: Discover the crafty equation
+if options.flags.n > 4
+  f = options.flags.f
+  if f >= 1 and f <= 7
+    n_limit = 24
+  elsif f >= 8 and f <= 23
+    n_limit = 23
+  elsif f >= 24 and f <= 43 # < 2x
+    n_limit = 22
+  elsif f >= 44 and f <= 199 # > 4x
+    n_limit = 21
+  elsif f >= 200 and f <= 239 # > 1x
+    n_limit = 20
+  elsif f >= 240 and f <= 863 # > 3x
+    n_limit = 19
+  elsif f >= 864 and f <= 907 # > 1x
+    n_limit = 18
+  elsif f >= 908 and f <= 2999 # > 3x
+    n_limit = 17
+  elsif f >= 3000 and f <= 3061 # > 1x
+    n_limit = 16
+  elsif f >= 3062 and f <= 9859 # > 3x
+    n_limit = 15
+  elsif f >= 9859 and f <= 31489 # > 3x
+    n_limit = 14
+  elsif f >= 31490 and f <= 99839 # > 3x
+    n_limit = 13
+  elsif f >= 99839 and f <= 316097 # > 3x
+    n_limit = 12
+  elsif f >= 316098 and f <= 999863 # > 3x
+    n_limit = 11
+  elsif f >= 999863 and f <= 3162149 # > 3x
+    n_limit = 10
+  elsif f >= 3162150 and f <= 31622699 # > 10x
+    n_limit = 9
+  elsif f >= 31622700 and f <= 316227671 # > 10x
+    n_limit = 8
+  elsif f >= 316227672 and f <= 9999999851 # > 30x
+    n_limit = 7
+  elsif f >= 9999999852 and f <= 999999999877 # > 100x
+    n_limit = 6
+  elsif f >= 999999999878 and f <= 99999999999931 # > 100x
+    n_limit = 5
+  elsif f >= 99999999999932 and f <= 9007199254740727 # Would be > 100x except JS times out
+    n_limit = 4
+  end
+  if options.flags.n > n_limit
+    options.flags.n = n_limit
+    messages.push("Warning! Table display (N) is limited to #{n_limit} for F of #{f}. More don't really fit nicely on the screen.")
+  end
 end
 
 # Otherwise we do various things based on the options.
-# TODO: DRY this up! I'm repeating myself a lot right here.
 if options.flags.version
-  puts "PrimeTable v#{PrimeTable::VERSION}"
+  messages.push("PrimeTable v#{PrimeTable::VERSION}")
 end
-if options.flags.time
-  Timer.timer{
-    if options.flags.f && options.flags.f > 0
-      if options.flags.n && options.flags.n > 0
-        PrimeTable.new(options.flags.f,options.flags.n,options.flags.prime_method)
-      else
-        # TODO: Pass a hash or args so I don't have order-dependency forcing redundant defaults
-        PrimeTable.new(options.flags.f,10,options.flags.prime_method)
-      end
-    else
-      if options.flags.n && options.flags.n > 0
-        # TODO: Pass a hash or args so I don't have order-dependency forcing redundant defaults
-        PrimeTable.new(2,options.flags.n,options.flags.prime_method)
-      else
-        # TODO: Pass a hash or args so I don't have order-dependency forcing redundant defaults
-        PrimeTable.new(2,10,options.flags.prime_method)
-      end
-    end
-  }
-  puts "PrimeTable completed in #{Timer.time}"
-else
-  if options.flags.f && options.flags.f > 0
-      if options.flags.n && options.flags.n > 0
-        PrimeTable.new(options.flags.f,options.flags.n,options.flags.prime_method)
+
+# TODO: DRY this up! I'm repeating myself a lot right here.
+if ARGS != ["-h"]
+  if options.flags.time
+    Timer.timer{
+      if options.flags.f && options.flags.f > 0
+        if options.flags.n && options.flags.n > 0
+          PrimeTable.new(options.flags.f,options.flags.n,options.flags.prime_method)
+        else
+          # TODO: Pass a hash or args so I don't have order-dependency forcing redundant defaults
+          PrimeTable.new(options.flags.f,10,options.flags.prime_method)
+        end
       else
-        # TODO: Pass a hash or args so I don't have order-dependency forcing redundant defaults
-        PrimeTable.new(options.flags.f,10,options.flags.prime_method)
+        if options.flags.n && options.flags.n > 0
+          # TODO: Pass a hash or args so I don't have order-dependency forcing redundant defaults
+          PrimeTable.new(2,options.flags.n,options.flags.prime_method)
+        else
+          # TODO: Pass a hash or args so I don't have order-dependency forcing redundant defaults
+          PrimeTable.new(2,10,options.flags.prime_method)
+        end
       end
-    else
-      if options.flags.n && options.flags.n > 0
-        # TODO: Pass a hash or args so I don't have order-dependency forcing redundant defaults
-        PrimeTable.new(2,options.flags.n,options.flags.prime_method)
+    }
+    messages.push("PrimeTable completed in #{Timer.time}")
+  else
+    if options.flags.f && options.flags.f > 0
+        if options.flags.n && options.flags.n > 0
+          PrimeTable.new(options.flags.f,options.flags.n,options.flags.prime_method)
+        else
+          # TODO: Pass a hash or args so I don't have order-dependency forcing redundant defaults
+          PrimeTable.new(options.flags.f,10,options.flags.prime_method)
+        end
       else
-        # TODO: Pass a hash or args so I don't have order-dependency forcing redundant defaults
-        PrimeTable.new(2,10,options.flags.prime_method)
+        if options.flags.n && options.flags.n > 0
+          # TODO: Pass a hash or args so I don't have order-dependency forcing redundant defaults
+          PrimeTable.new(2,options.flags.n,options.flags.prime_method)
+        else
+          # TODO: Pass a hash or args so I don't have order-dependency forcing redundant defaults
+          PrimeTable.new(2,10,options.flags.prime_method)
+        end
       end
-    end
+  end
 end
+
+# Now display any messages we have accumualted above
+messages.each{|message|
+  puts message
+}
+
+# And finally the help if they asked for it
 if options.flags.help
   puts options.flags.help
 end
-# Eventually, we hope to allow the user to pass a first|start flag as well; currently defaulting to 1
 
 exit

data/lib/primetable.rb

@@ -63,11 +63,11 @@ class PrimeTable
     # 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 # Using precalculated values from code. 3-8ms on benchmark run.
+      when :fast # Using precalculated values from code. 8-17ms, mode 13ms on benchmark (2,10) run, 14-24ms/20ms on (200000,12)
         fast_primes(first,count)
-      when :load # Using precalculated values from file. 13-23ms on benchmark run.
+      when :load # Using precalculated values from file. 45-256ms, mode 50ms on benchmark (2,10) run, 669-913ms/681ms on (200000,12)
         load_primes(first,count)
-      when :calc # Using JS generated values. 8-16ms on benchmark run.
+      when :calc # Using JS generated values. 14-84ms, Mode 18ms on benchmark (2,10) run, 17-25ms/21ms on (200000,12)
         calc_primes(first,count)
     end # case prime_method
 
@@ -96,11 +96,11 @@ class PrimeTable
 
     # Previously, the 'first' argument was an index, now it's a best guess for the first prime,
     # so we have to find the index in order to find the line number
-    if first === 1
+    if first == 1
       first = 2
     end
 
-    if first === 2
+    if first == 2
       wb_before = ""
     else
       wb_before = ","
@@ -113,9 +113,9 @@ class PrimeTable
     end
 
     grep_result = []
-    while grep_result === []
+    while grep_result == []
       grep_result = `grep -n -e "#{wb_before}#{first}#{wb_after}" data/prime.dat`.split(":")
-      if grep_result === []
+      if grep_result == []
         first = first + 1
       end
     end
@@ -149,9 +149,9 @@ class PrimeTable
   # TODO: Include note on average run time using this method.
   def calc_primes(first, count)
 
-    # One nice thing about this is that I can easily set a timeout, so I someone asks us to run
-    # some astronomical prime, we won't seize up the CPU forever. 700ms is arbitrary.
-    calc_primes_js = V8::Context.new timeout: 700
+    # One nice thing about this is that I can easily set a timeout, so if someone asks us to run
+    # some astronomical prime, we won't seize up the CPU forever. 7000ms is arbitrary.
+    calc_primes_js = V8::Context.new timeout: 7000
     File.open("js/prime.js") do |file|
       calc_primes_js.eval(file, "js/prime.js")
     end

data/lib/primetable/version.rb

@@ -1,3 +1,3 @@
 class PrimeTable
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/primetable.gemspec

@@ -21,8 +21,8 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'therubyracer', '~> 0.12', '>= 0.12.2'
   spec.add_runtime_dependency 'formatador', '~> 0.2', '>= 0.2.5'
 
-  spec.add_development_dependency "bundler", "~> 1.6"
-  spec.add_development_dependency "rake", '~> 10.4', '>= 10.4.2'
-  spec.add_development_dependency "rspec", '~> 3.4', '>= 3.4.0'
-  spec.add_development_dependency "pry"
+  spec.add_development_dependency 'bundler', "~> 1.6"
+  spec.add_development_dependency 'rake', '~> 10.4', '>= 10.4.2'
+  spec.add_development_dependency 'rspec', '~> 3.4', '>= 3.4.0'
+  spec.add_development_dependency 'pry', '~> 0.10', '>= 0.10.2'
 end

data/spec/primetable_spec.rb

@@ -5,8 +5,15 @@ describe PrimeTable do
     @expected_execution_output = "PrimeTable is running...\n"
     @expected_time_output = "ms"
     @expected_version_output = PrimeTable::VERSION
-    @expected_help_output = "Common options:
+    @expected_help_output = "Usage: primetable [options]
+
+Specific options:
+    -f F                             First prime (default is 2, limit is 2000003 w/ -m load|fast, 9007199254740727 w/ -m calc)
+    -n N                             Number of primes for which you wish to generate a table
+    -m, --method METHOD              Select method of generating primes (fast|load|calc) (default is 'calc')
     -t, --time                       Display run time
+
+Common options:
     -h, --help                       Show this message
     -v, --version                    Show version"
     @expected_first_ten_primes = [2,3,5,7,11,13,17,19,23,29]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: primetable
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Day Davis Waterbury
@@ -108,16 +108,22 @@ dependencies:
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.10.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.10.2
 description: Displays the products of N primes in a table format. Optionally uses
   generated primes or precalculated.
 email: