sieve 0.0.2 → 0.1.0

data/README.markdown

@@ -13,7 +13,7 @@ Install with Rubygems:
 A method is added to the Numeric class.
 
     5.sieve  # [2, 3, 5]
-    20.sieve # [2, 3, 5, 7, 11, 13, 17]
+    20.sieve # [2, 3, 5, 7, 11, 13, 17, 19]
 
 ## Benchmarks
 
@@ -37,17 +37,30 @@ As far as I know, this is the most optimized pure Ruby sieve written.
 
 The benchmarks were run on a 2.8GHz Intel Core 2 Duo MacBook Pro with 8 GB memory.
 
-Ruby 1.8.7p253 REE 2010.02
+ruby 1.8.6 (2010-02-05 patchlevel 399) [i686-darwin10.4.0]
 
                         user     system      total        real
-    sieve method    32.820000   0.710000  33.530000 ( 33.727176)
-    Numeric#sieve    1.040000   0.420000   1.460000 (  1.476743)
+    sieve method    41.430000   0.600000  42.030000 ( 42.261872)
+    Numeric#sieve    1.010000   0.250000   1.260000 (  1.342326)
 
-Ruby 1.9.2p0
+ruby 1.8.7 (2010-08-16 patchlevel 302) [i686-darwin10.4.0]
 
                         user     system      total        real
-    sieve method    21.460000   0.620000  22.080000 ( 22.170883)
-    Numeric#sieve    0.940000   0.320000   1.260000 (  1.262891)
+    sieve method    41.720000   0.730000  42.450000 ( 43.640117)
+    Numeric#sieve    0.960000   0.380000   1.340000 (  1.385924)
+
+ruby 1.8.7 (2010-04-19 patchlevel 253) [i686-darwin10.4.0], MBARI 0x6770, Ruby Enterprise Edition 2010.02
+
+                        user     system      total        real
+    sieve method    42.800000   0.910000  43.710000 ( 45.105879)
+    Numeric#sieve    1.090000   0.370000   1.460000 (  1.517832)
+
+
+ruby 1.9.2p0 (2010-08-18 revision 29036) [x86_64-darwin10.4.0]
+
+                        user     system      total        real
+    sieve method    22.800000   0.670000  23.470000 ( 24.132390)
+    Numeric#sieve    1.000000   0.380000   1.380000 (  1.422877)
 
 ## Author
 

data/Rakefile

@@ -1,5 +1,7 @@
 require "rubygems"
 require "rake"
+require "benchmark"
+require "sieve"
 
 require "rake/extensiontask"
 Rake::ExtensionTask.new("sieve") do |extension|
@@ -12,3 +14,34 @@ Cucumber::Rake::Task.new(:cucumber => [:clean, :compile]) do |t|
 end
 
 task :default => :cucumber
+
+desc "Benchmark C implementation against pure Ruby implementation of the Sieve"
+task(:benchmark => [:clean, :compile]) do
+  def sieve(n)
+    numbers = (0..n).map {|i| i }
+    numbers[0] = numbers[1] = nil
+    numbers.each do |num|
+      next unless num
+      break if num**2 > n
+      (num**2).step(n, num) {|idx| numbers[idx] = nil }
+    end
+    numbers.compact
+  end
+
+  Benchmark.bmbm(15) do |benchmark|
+    range = (0..1000000)
+    step = 10000
+
+    benchmark.report("sieve method") do
+      range.step(step) do |i|
+        sieve(i)
+      end
+    end
+
+    benchmark.report("Numeric#sieve") do
+      range.step(step) do |i|
+        i.sieve
+      end
+    end
+  end
+end

data/ext/sieve/sieve.c

@@ -10,22 +10,23 @@ void Init_sieve() {
 }
 
 static VALUE sieve(const VALUE self) {
-  if(rb_num2long(self) < 0) { return Qnil; }
-  long number = rb_num2long(self) + 1,
+  if(NUM2LONG(self) < 2) { return Qnil; }
+  long number = NUM2LONG(self) + 1,
      * numbers = malloc(number * sizeof(long));
 
-  if(numbers == NULL) { return Qnil; }
-
-  long i;
-  for(i = 0; i < number; i++) {
-    numbers[i] = i;
+  if(numbers == NULL) {
+    rb_raise(rb_eNoMemError, "Can't allocate enough memory.");
   }
+
   numbers[0] = numbers[1] = -1;
+  long i;
+  for(i = 2; i < number; i++) { numbers[i] = i; }
 
   long current_square;
   for(i = 0; i < number; i++) {
+    if(numbers[i] == -1) { continue; }
+
     current_square = powl(i, 2);
-    if(numbers[i] == -1)        { continue; }
     if(current_square > number) { break; }
 
     long n;
@@ -36,9 +37,8 @@ static VALUE sieve(const VALUE self) {
 
   VALUE primes_array = rb_ary_new();
   for(i = 0; i < number; i++) {
-    if(numbers[i] != -1) {
-      rb_ary_push(primes_array, LONG2FIX(numbers[i]));
-    }
+    if(numbers[i] == -1) { continue; }
+    rb_ary_push(primes_array, LONG2FIX(numbers[i]));
   }
 
   free(numbers);

data/features/sieve.feature

@@ -4,15 +4,15 @@ Feature: Sieve of Eratosthenes
   I should be able to call a sieve on a numeric to find its primes
 
   Scenario Outline: Find primes effectively
-    When I run a sieve on <number>
+    When I calculate the sieve for <number>
     Then I should have the primes <primes>
     Examples:
       | number | primes                                                                                 |
       | -12345 | nil                                                                                    |
       | -5     | nil                                                                                    |
       | -1     | nil                                                                                    |
-      | 0      |                                                                                        |
-      | 1      |                                                                                        |
+      | 0      | nil                                                                                    |
+      | 1      | nil                                                                                    |
       | 2      | 2                                                                                      |
       | 3      | 2,3                                                                                    |
       | 4      | 2,3                                                                                    |
@@ -23,7 +23,11 @@ Feature: Sieve of Eratosthenes
       | 30     | 2,3,5,7,11,13,17,19,23,29                                                              |
       | 110    | 2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109 |
 
+  Scenario: Allocating memory for the sieve raises an exception if it fails
+    When I calculate the sieve for 1000000000000000000
+    Then a NoMemoryError should be raised
+
   Scenario: Prime tables
     When I load all the primes from "features/support/primes.txt"
-    And I run a sieve on the last number
+    And I calculate the sieve for the last number
     Then I should have all primes from "features/support/primes.txt"

data/features/step_definitions/sieve_steps.rb

@@ -1,15 +1,16 @@
-When /^I run a sieve on (\-?\d+)$/ do |number|
-  @result = number.to_i.sieve
+When /^I calculate the sieve for (\-?\d+)$/ do |number|
+  begin
+    @result = number.to_i.sieve
+  rescue Exception => @sieve_exception
+  end
 end
 
 Then /^I should have the primes (.*)$/ do |primes|
   case primes
   when "nil"
     @result.should be_nil
-  when ""
-    @result.should be_empty
   else
-    @primes = primes.split(",").map(&:strip).map(&:to_i)
+    @primes = primes.split(",").map {|prime| prime.to_i }
     @result.should == @primes
   end
 end
@@ -19,17 +20,27 @@ When /^I load all the primes from "([^"]*)"$/ do |path|
   @primes.should_not be_empty
 end
 
-When /^I run a sieve on the last number$/ do
-  @result = @primes.last.sieve
+When /^I calculate the sieve for the last number$/ do
+  When %{I calculate the sieve for #{@primes.last}}
 end
 
 Then /^I should have all primes from "([^"]*)"$/ do |path|
   Then %{I should have the primes #{prime_file_process(path).join(",")}}
 end
 
+Then /^a NoMemoryError should be raised$/ do
+  @sieve_exception.should be_a(NoMemoryError)
+end
+
 module PrimeFileProcessor
   def prime_file_process(path)
-    File.new(path).read.strip.split(/\s+/).map(&:to_i)
+    @processed_cache ||= {}
+
+    if @processed_cache[path]
+      @processed_cache[path]
+    else
+      @processed_cache[path] = File.new(path).read.strip.split(/\s+/).map {|prime| prime.to_i }
+    end
   end
 end
 

data/lib/sieve.rb

@@ -1,4 +1,5 @@
 require "sieve/sieve"
 
 module Sieve
+  VERSION = "0.1.0"
 end

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: sieve
 version: !ruby/object:Gem::Version 
-  hash: 27
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 2
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors: 
 - Josh Clayton
@@ -15,11 +14,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-28 00:00:00 -04:00
+date: 2010-08-29 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
-description: 
+description: Ruby C Extension for the Sieve of Eratosthenes
 email: joshua.clayton@gmail.com
 executables: []
 
@@ -32,7 +31,6 @@ files:
 - MIT-LICENSE
 - README.markdown
 - Rakefile
-- benchmark.rb
 - ext/sieve/extconf.rb
 - ext/sieve/sieve.c
 - ext/sieve/sieve.h
@@ -56,7 +54,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -65,7 +62,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"

data/benchmark.rb

@@ -1,32 +0,0 @@
-#!/usr/bin/env ruby
-
-require "rubygems"
-require "benchmark"
-require "sieve"
-
-def sieve(n)
-  numbers = (0..n).map(&:to_i)
-  numbers[0] = numbers[1] = nil
-  numbers.each do |num|
-    next unless num
-    break if num**2 > n
-    (num**2).step(n, num) {|idx| numbers[idx] = nil }
-  end
-  numbers.compact
-end
-
-Benchmark.bm(15) do |benchmark|
-  range = (0..1000000)
-  step = 10000
-  benchmark.report("sieve method") do
-    range.step(step).each do |i|
-      sieve(i)
-    end
-  end
-
-  benchmark.report("Numeric#sieve") do
-    range.step(step).each do |i|
-      i.sieve
-    end
-  end
-end