sieve 0.0.1 → 0.0.2

data/README.markdown

@@ -35,12 +35,19 @@ The sieve method itself looks like this:
 
 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
+
                         user     system      total        real
     sieve method    32.820000   0.710000  33.530000 ( 33.727176)
     Numeric#sieve    1.040000   0.420000   1.460000 (  1.476743)
 
-These benchmarks were taken running Ruby 1.8.7p253 REE 2010.02.
-The machine is a 2.8GHz Intel Core 2 Duo MacBook Pro with 8 GB memory.
+Ruby 1.9.2p0
+
+                        user     system      total        real
+    sieve method    21.460000   0.620000  22.080000 ( 22.170883)
+    Numeric#sieve    0.940000   0.320000   1.260000 (  1.262891)
 
 ## Author
 

data/benchmark.rb

@@ -0,0 +1,32 @@
+#!/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

data/ext/sieve/sieve.c

@@ -3,15 +3,16 @@
 #include "sieve.h"
 
 void Init_sieve() {
-  VALUE rb_mSieve = rb_define_module("Sieve");
-  VALUE numeric = rb_define_class("Numeric", rb_cObject);
+  VALUE rb_mSieve = rb_define_module("Sieve"),
+        numeric   = rb_define_class("Numeric", rb_cObject);
   rb_define_method(rb_mSieve, "sieve", sieve, 0);
   rb_include_module(numeric, rb_mSieve);
 }
 
-VALUE sieve(VALUE self) {
-  long number = rb_num2long(self) + 1;
-  long *numbers = malloc(number * sizeof(long));
+static VALUE sieve(const VALUE self) {
+  if(rb_num2long(self) < 0) { return Qnil; }
+  long number = rb_num2long(self) + 1,
+     * numbers = malloc(number * sizeof(long));
 
   if(numbers == NULL) { return Qnil; }
 
@@ -21,13 +22,14 @@ VALUE sieve(VALUE self) {
   }
   numbers[0] = numbers[1] = -1;
 
+  long current_square;
   for(i = 0; i < number; i++) {
-    long current_sq = powl(i, 2);
-    if(numbers[i] == -1)    { continue; }
-    if(current_sq > number) { break; }
+    current_square = powl(i, 2);
+    if(numbers[i] == -1)        { continue; }
+    if(current_square > number) { break; }
 
     long n;
-    for(n = current_sq; n < number; n += i) {
+    for(n = current_square; n < number; n += i) {
       numbers[n] = -1;
     }
   }
@@ -40,5 +42,6 @@ VALUE sieve(VALUE self) {
   }
 
   free(numbers);
+
   return primes_array;
 }

data/ext/sieve/sieve.h

@@ -1,4 +1,4 @@
 #ifndef __sieve_h__
 #define __sieve_h__
-VALUE sieve(VALUE);
+static VALUE sieve(VALUE);
 #endif

data/features/sieve.feature

@@ -8,6 +8,11 @@ Feature: Sieve of Eratosthenes
     Then I should have the primes <primes>
     Examples:
       | number | primes                                                                                 |
+      | -12345 | nil                                                                                    |
+      | -5     | nil                                                                                    |
+      | -1     | nil                                                                                    |
+      | 0      |                                                                                        |
+      | 1      |                                                                                        |
       | 2      | 2                                                                                      |
       | 3      | 2,3                                                                                    |
       | 4      | 2,3                                                                                    |

data/features/step_definitions/sieve_steps.rb

@@ -1,10 +1,17 @@
-When /^I run a sieve on (\d+)$/ do |number|
+When /^I run a sieve on (\-?\d+)$/ do |number|
   @result = number.to_i.sieve
 end
 
 Then /^I should have the primes (.*)$/ do |primes|
-  @primes = primes.split(",").map(&:strip).map(&:to_i)
-  @result.should == @primes
+  case primes
+  when "nil"
+    @result.should be_nil
+  when ""
+    @result.should be_empty
+  else
+    @primes = primes.split(",").map(&:strip).map(&:to_i)
+    @result.should == @primes
+  end
 end
 
 When /^I load all the primes from "([^"]*)"$/ do |path|

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sieve
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Josh Clayton
@@ -32,10 +32,11 @@ files:
 - MIT-LICENSE
 - README.markdown
 - Rakefile
-- lib/sieve.rb
+- benchmark.rb
 - ext/sieve/extconf.rb
 - ext/sieve/sieve.c
 - ext/sieve/sieve.h
+- lib/sieve.rb
 - cucumber.yml
 - features/sieve.feature
 - features/step_definitions/sieve_steps.rb