primetable 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 06b99246be7a2bfd75f92c7fc00da6244f58e47f
-  data.tar.gz: 4150b339ac4d875941fae7b3bc09777e431f28ee
+  metadata.gz: 299f5fbd29ce75cf104d0f2be372821a59d2d776
+  data.tar.gz: 9c18c6aef7dc6c7c500b8902399502a7527712db
 SHA512:
-  metadata.gz: c9d32659b42c562551f8fe7365c990aa91a67e8a6eca00f99311010d8ce01b2f50b648bbc174bf9ec25886122346b491d8ddb40411888252c6c0d2eca8040716
-  data.tar.gz: f67ba3a6d0d7de34e50eace6719ee3efde83e0c4279a19e0b7192b26598eda02207899e0406a2ece6801080dfbf036c5c2ce03b45e13a853521dba100073dff4
+  metadata.gz: dcb03e51222e85965ad491a05d4accc773cea77882692ead9f166e800222451f2a7a8f679a6fd31dc0acfe43ddf94dc0d1c2a91b081d5a4048d4860ff11de730
+  data.tar.gz: c59603ca941d2cf1fca3f141e25f19165318572cfd95231d2edf44ba909a992dfe16dcb1d1a3eee1e4c17ab4387e765c4c3f477df111c1a6b9b3bafcfead4642

data/Gemfile.lock

@@ -1,14 +1,18 @@
 PATH
   remote: .
   specs:
-    primetable (0.2.0)
+    primetable (0.2.3)
+      awesome_print (~> 1.6, >= 1.6.1)
+      therubyracer (~> 0.12.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
     awesome_print (1.6.1)
     diff-lcs (1.2.5)
+    libv8 (3.16.14.13)
     rake (10.4.2)
+    ref (2.0.0)
     rspec (3.4.0)
       rspec-core (~> 3.4.0)
       rspec-expectations (~> 3.4.0)
@@ -22,16 +26,18 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.4.0)
     rspec-support (3.4.0)
+    therubyracer (0.12.2)
+      libv8 (~> 3.16.14.0)
+      ref
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  awesome_print
   bundler (~> 1.6)
   primetable!
-  rake
-  rspec
+  rake (~> 10.4, >= 10.4.2)
+  rspec (~> 3.4, >= 3.4.0)
 
 BUNDLED WITH
    1.10.6

data/data/prime.dat

@@ -13410,4 +13410,4 @@
 [1999121,1999163,1999177,1999187,1999211,1999219,1999223,1999243,1999247,1999273]
 [1999297,1999301,1999303,1999307,1999331,1999339,1999343,1999363,1999379,1999681]
 [1999691,1999703,1999721,1999733,1999771,1999799,1999817,1999819,1999853,1999859]
-[1999867,1999871,1999889,1999891,1999957,1999969,1999979,1999993]
+[1999867,1999871,1999889,1999891,1999957,1999969,1999979,1999993,2000003,2000029]

data/js/prime.js

@@ -0,0 +1,87 @@
+var factors = [];
+var primes = [];
+
+function libPrime(method, n) {
+  if (method === "isPrime" && n === 1) {
+    return false;
+  }
+  if (method === "generatePrimes") {
+    var count = 10;
+    // console.log("primes.length:"+primes.length);
+    while (primes.length<count) {
+      if (isPrime(n) && (primes.indexOf(n) === -1)) {
+        // console.log("isPrime(n):true:"+n);
+        primes.push(n);
+        // console.log("primes:"+primes+", primes.length:"+primes.length);
+      } else {
+        // console.log("isPrime(n):false:"+n);
+        n++;
+        generatePrimes(n);
+      }
+    }
+    return primes;
+  }
+  // console.log("* n:"+n);
+  // We don't care about divisibility by 1, so we begin at 2
+  var divisor = 2;
+
+  // If a suitable divisor exists it will be less than or equal to the square root of n
+  // Due to the commutative property of multiplication
+  while ((divisor <= Math.floor(Math.sqrt(n)))) {
+    // console.log("** n:"+n+", divisor:"+divisor+", n % divisor:"+(n % divisor));
+    if (!(n % divisor)) {
+      // console.log("*** n:"+n+", divisor:"+divisor);
+      // If n is divisible with remainder zero, then it's non-prime
+      switch (method) {
+      case "isPrime":
+        return false;
+      case "primeFactors":
+        // The divisor will always be a prime factor
+        factors.push(divisor);
+        // The quotient may or may not be prime, so we recurse here
+        // console.log("**** n:"+n+", divisor:"+divisor+", n/divisor:"+n/divisor);
+        primeFactors(n/divisor);
+        return factors;
+      }
+    }
+    else {
+      // If n is not evenly divisible then we increment the divisor and continue
+      if (divisor >= 3) {
+        divisor += 2; // Because all even numbers > 2 are non-prime
+      } else {
+        divisor += 1; // Just once, from 2 to 3
+      }
+    }
+  }
+  switch (method) {
+  case "isPrime":
+    return true;
+  case "primeFactors":
+    factors.push(n);
+    return factors;
+  case "generatePrimes":
+    primes.push(n);
+  }
+}
+
+// Returns true if n is prime
+function isPrime(n) {
+  return libPrime("isPrime",n);
+}
+
+// Returns n if prime, or the prime factors of n if composite
+function primeFactors(n) {
+  return libPrime("primeFactors",n);
+}
+
+// Generate an array of prime numbers greater than or equal to n with length count
+function generatePrimes(n) {
+  return libPrime("generatePrimes",n);
+}
+// Try it out
+// // console.log(isPrime(1));
+// console.log(generatePrimes(1999867));
+// Try it out
+// for (var i = 1; i < 1002; i++) {
+//   // console.log(i + " is " + (isPrime(i) ? "PRIME" : "COMPOSITE") + (!(isPrime(i)) ? (": " + primeFactors(i)) : ""));
+// }

data/lib/primetable.rb

@@ -1,5 +1,5 @@
-# Not sure why this is here. I'll have to experiment with taking it out.
-require "primetable/version"
+# Require modules from the lib/primetable directory...right now it's just our VERSION constant
+Dir["#{File.dirname(__FILE__)}/primetable/**/*.rb"].each { |f| require(f) }
 
 # This is needed for load_primes method, which loads data from a file.
 require "yaml"
@@ -7,13 +7,18 @@ require "yaml"
 # I'll probably remove this later, but it's my interim table display solution.
 require "awesome_print"
 
+# So, just for fun, I'm going to write my Ruby prime generation method and a few others as
+# wrappers for some JS functionality I've already written. We'll test as usual. Perhaps, if
+# I ever get around to writing Ruby native versions, we can have them race eachother.
+require "v8"
+
 # 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)
+  def initialize(first=1, count=10, prime_method=:fast, suppress_output=false)
 
     # This is only for testing, I'm unlikely to implement a command-line flag for this
     unless suppress_output
@@ -22,7 +27,7 @@ class PrimeTable
     end
 
     # Ye olde instance variables
-    @primes = init_primes(:load,first,count)
+    @primes = init_primes(prime_method,first,count)
     @table = build_data(@primes)
 
     # I added this suppress_output so I could run certain tests without a huge, admittly
@@ -39,12 +44,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 # 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
+      when :fast # Using precalculated values from code. 3-8ms on benchmark run.
+        PrimeTable::PRIMES.slice(first-1,count)
+      when :load # Using precalculated values from file. 13-23ms on benchmark run.
         load_primes(first,count)
-      when :calc # The slowest, but presumably preferred, method in our arsenal
+      when :calc # Using JS generated values. 8-16ms on benchmark run.
         calc_primes(first,count)
     end # case prime_method
 
@@ -55,21 +59,29 @@ 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
+    File.open("js/prime.js") do |file|
+      calc_primes_js.eval(file, "js/prime.js")
+    end
+    primes_js = calc_primes_js.eval("generatePrimes(#{first})")
+    primes = YAML::load("[#{primes_js}]")
+    return primes
+
   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.
+  # file is currently 2000029, 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."
+    # Again, we only have the first 134130 primes in here right now
+    if (first + count) > 134130
+      throw "We only have the first 134130 primes in the data file right now. Please pass -c to use calculated primes."
     end
 
     # An array to keep our prime numbers in, right?
@@ -77,10 +89,8 @@ class PrimeTable
 
     # 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

data/lib/primetable/version.rb

@@ -1,3 +1,3 @@
 class PrimeTable
-  VERSION = "0.2.2"
+  VERSION = "0.2.4"
 end

data/primetable.gemspec

@@ -19,6 +19,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency "awesome_print", '~> 1.6', '>= 1.6.1'
+  spec.add_runtime_dependency 'therubyracer', '~> 0.12.2'
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake", '~> 10.4', '>= 10.4.2'

data/spec/primetable_spec.rb

@@ -22,9 +22,11 @@ describe PrimeTable do
                                              [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
@@ -46,7 +48,7 @@ describe PrimeTable do
     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`
+    execution_output = `primetable --time --version`
     expect(execution_output).to include(@expected_execution_output)
     expect(execution_output).to include(@expected_time_output)
     expect(execution_output).to include(@expected_version_output)
@@ -57,9 +59,20 @@ describe PrimeTable do
     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
+  it "has the right data when we run it with :fast" do
+    test_instance = PrimeTable.new(1,10,:fast,true)
+    expect(test_instance.primes).to eq(@expected_first_ten_primes)
+    expect(test_instance.table).to eq(@expected_table_with_first_ten_primes)
+  end
+  it "has the right data when we run it with :calc" do
+    test_instance = PrimeTable.new(1,10,:calc,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.2.2
+  version: 0.2.4
 platform: ruby
 authors:
 - Day Davis Waterbury
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-21 00:00:00.000000000 Z
+date: 2015-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: awesome_print
@@ -30,6 +30,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.6.1
+- !ruby/object:Gem::Dependency
+  name: therubyracer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -102,6 +116,7 @@ files:
 - Rakefile
 - bin/primetable
 - data/prime.dat
+- js/prime.js
 - lib/primetable.rb
 - lib/primetable/version.rb
 - lib/timer.rb