ruby_array_find_consecutive 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+lib/*.so
+lib/*.bundle
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ruby_array_consecutive.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 richardcalahan
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,52 @@
+## Ruby C extension for Array#find_consecutive
+
+### Description
+   
+`Array#find_consecutive` is a Ruby C extension. It returns an array of non-overlapping arrays of consecutive numbers for `self` for a given interval. If no interval argument is provided the default is 1. That's a mouthful, so perhaps an example will help.
+
+### Usage
+
+```
+
+[1, 2, 3, 4, 5].find_consecutive
+# => [[1, 2, 3, 4, 5]]
+
+[1, 2, 3, 4, 5, 10, 4, 5, 6, 7, 8].find_consecutive
+# => [[1, 2, 3, 4, 5], [4, 5, 6, 7, 8]]
+
+[1, 2, 3, 4, 6, 8, 10, 12, 14].find_consecutive(2)
+# => [[4, 6, 8, 10, 12, 14]]
+
+[1, 2, 3.5, 5, 6.5, 8, 9, 10, 11.5, 13].find_consecutive(1.5)
+# => [[2, 3.5, 5, 6.5, 8], [10, 11.5, 13]]
+
+```
+
+### And...it's fast!
+
+The benchmark suite interates an array of length > 2,000,000 using the C extension and a pure Ruby implementation.
+
+```
+
+$ ./benchmark
+                                               user     system      total        real
+find_consecutive C    (integer interval)   0.460000   0.000000   0.460000 (  0.459470)
+find_consecutive Ruby (integer interval)   1.030000   0.000000   1.030000 (  1.030171)
+find_consecutive C    (float interval)     0.390000   0.000000   0.390000 (  0.394497)
+find_consecutive Ruby (float interval)     1.500000   0.010000   1.510000 (  1.506115)   
+
+```
+   
+### Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ruby_array_find_consecutive'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ruby_array_find_consecutive

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake'
+require 'rake/extensiontask'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new :spec
+Rake::ExtensionTask.new 'ruby_array_find_consecutive'
+
+task :default => [ :compile, :spec ]

data/benchmark

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require 'benchmark'
+require 'ruby_array_consecutive'
+
+# A pure ruby implementation of Array#consecutive
+class Array
+  def r_consecutive step=1
+    r_ary, c_ary = [[], []]
+    self.each_with_index do |v, i|
+      n = self[i+1]
+      c_ary << v if c_ary.length == 0
+      if v + step == n
+        c_ary << n
+      else
+        r_ary << c_ary if c_ary.length > 1
+        c_ary = []
+      end
+    end    
+    return r_ary
+  end
+end
+
+array = (1..1000000).map { rand(1..100) }
+array += [5, 6, 7, 8, 9]
+array += [1, 2.5, 4, 5.5, 7, 8.5]
+array += (1..1000000).map { rand(1..100) }
+
+Benchmark.bmbm do |x|
+  x.report 'consecutive C    (integer interval)' do 
+    array.consecutive
+  end
+
+  x.report 'consecutive Ruby (integer interval)' do 
+    array.r_consecutive
+  end
+
+  x.report 'consecutive C    (float interval)' do 
+    array.consecutive(1.5)
+  end
+
+  x.report 'consecutive Ruby (float interval)' do 
+    array.r_consecutive(1.5)
+  end
+end

data/ext/ruby_array_find_consecutive/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile 'ruby_array_find_consecutive'

data/ext/ruby_array_find_consecutive/ruby_array_find_consecutive.c

@@ -0,0 +1,59 @@
+#include <stdio.h>
+#include "ruby.h"
+
+static VALUE 
+rb_arr_find_consecutive ( int argc, VALUE *argv, VALUE self )
+{    
+    if ( argc > 1 ) { 
+        rb_raise(rb_eArgError, "wrong number of arguments (%i for 0..1)", argc);
+    } 
+
+    double step;
+
+    if ( argc == 1 && TYPE(argv[0]) == T_FLOAT ) {
+        step = NUM2DBL(argv[0]);
+    } else if ( argc == 1 && TYPE(argv[0]) == T_FIXNUM ) {
+        step = NUM2INT(argv[0]);
+    } else {
+        step = 1;
+    }
+
+    VALUE r_ary = rb_ary_new();
+    VALUE c_ary = rb_ary_new();
+
+    long int max = RARRAY_LEN(self);
+    double c, n;
+    int i;
+    for ( i = 0; i < max; i++ ) {
+        VALUE ce = rb_ary_entry(self, i);
+        VALUE ne = rb_ary_entry(self, i + 1);
+
+        c = TYPE(ce) == T_FLOAT ? NUM2DBL(ce) : FIX2INT(ce);
+
+        if ( TYPE(ne) == T_FLOAT ) {
+            n = NUM2DBL(ne);
+        } else if ( TYPE(ne) == T_FIXNUM ) {
+            n = FIX2INT(ne);
+        }
+
+        if ( RARRAY_LEN(c_ary) == 0 ) {
+            VALUE c_ary_e = TYPE(ce) == T_FLOAT ? rb_float_new(c) : INT2FIX(c); 
+            rb_ary_push(c_ary, c_ary_e);
+        }
+
+        if ( c + step == n ) {
+            VALUE c_ary_e = TYPE(ne) == T_FLOAT ? rb_float_new(n) : INT2FIX(n);
+            rb_ary_push(c_ary, c_ary_e);
+        } else {
+            if ( RARRAY_LEN(c_ary) > 1 ) rb_ary_push(r_ary, c_ary);
+            c_ary = rb_ary_new();
+        }
+    }
+
+    return r_ary;
+}
+
+void Init_ruby_array_find_consecutive ( void ) 
+{
+    rb_define_method(rb_cArray, "find_consecutive", rb_arr_find_consecutive, -1);
+}

data/ruby_array_find_consecutive.gemspec

@@ -0,0 +1,18 @@
+Gem::Specification.new do |gem|
+  gem.name          = 'ruby_array_find_consecutive'
+  gem.version       = '0.0.1'
+  gem.authors       = ['Richard Calahan']
+  gem.email         = ['richard@calahan.me']
+  gem.description   = 'Provides a C level extension to Ruby, Array#find_consecutive'
+  gem.summary       = 'Array#find_consecutive implementation'
+  gem.homepage      = ''
+  gem.files         = `git ls-files`.split($/)
+  gem.extensions    = ['ext/ruby_array_find_consecutive/extconf.rb']
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rake-compiler'
+  gem.add_development_dependency 'rspec'
+  gem.test_files  = Dir.glob "spec/**/*_spec.rb"
+end

data/spec/ruby_array_consecutive_spec.rb

@@ -0,0 +1,34 @@
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+
+require 'spec_helper'
+require 'ruby_array_find_consecutive'
+
+describe Array do 
+  it 'finds 1 array of consecutive integers incrementing by 1' do
+    [1, 2, 3].find_consecutive.length.should == 1
+  end
+
+  it 'finds 2 arrays of consecutive integers incrementing by 1' do
+    [1, 2, 3, 5, 4, 5, 6].find_consecutive.length.should == 2
+  end
+
+  it 'finds 1 array of consecutive integers incrementing by 2' do
+    [1, 3, 5, 7, 9].find_consecutive(2).length.should == 1
+  end
+
+  it 'finds 2 arrays of consecutive integers incrementing by 2' do
+    [1, 3, 5, 7, 9, 3, 5, 7, 9, 11].find_consecutive(2).length.should == 2
+  end
+
+  it 'finds 1 array of consecutive integers incrementing by 1.5' do
+    [0, 1.5, 3, 4.5, 6].find_consecutive(1.5).length.should == 1
+  end
+
+  it 'finds 2 arrays of consecutive integers incrementing by 1.5' do
+    [0, 1.5, 3, 4.5, 6, 3, 4.5].find_consecutive(1.5).length.should == 2
+  end
+
+  it 'finds 0 arrays of consecutive integers incrementing 1' do
+    [0, 1.5, 3, 4.5, 6, 3, 4.5].find_consecutive(1).length.should == 0
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # config.treat_symbols_as_metadata_keys_with_true_values = true
+  # config.run_all_when_everything_filtered = true
+  # config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: ruby_array_find_consecutive
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Richard Calahan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Provides a C level extension to Ruby, Array#find_consecutive
+email:
+- richard@calahan.me
+executables: []
+extensions:
+- ext/ruby_array_find_consecutive/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmark
+- ext/ruby_array_find_consecutive/extconf.rb
+- ext/ruby_array_find_consecutive/ruby_array_find_consecutive.c
+- lib/.gitkeep
+- ruby_array_find_consecutive.gemspec
+- spec/ruby_array_consecutive_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Array#find_consecutive implementation
+test_files:
+- spec/ruby_array_consecutive_spec.rb