gem_with_extension_example 0.0.0

data/ext/infinity_check_c/InfinityCheckC.c

@@ -0,0 +1,44 @@
+// Include the Ruby headers and goodies
+#include "ruby.h"
+#include "math.h"
+#include "complex.h"
+
+// Defining a space for information and references about the module to be stored internally
+VALUE InfinityCheckC = Qnil;
+
+// Prototype for the initialization method - Ruby calls this, not you
+void Init_infinity_check_c();
+
+// Prototype for our method - methods are prefixed by 'method_' here
+VALUE method_infinity_check_c(VALUE self, VALUE limit, VALUE cr, VALUE ci, VALUE zr, VALUE zi);
+
+// The initialization method for this module
+void Init_infinity_check_c()
+{
+	InfinityCheckC = rb_define_module("InfinityCheckC");
+	rb_define_method(InfinityCheckC, "infinity_check_c", method_infinity_check_c, 5);
+}
+
+VALUE method_infinity_check_c(VALUE self, VALUE limit, VALUE cr, VALUE ci, VALUE zr, VALUE zi)
+{
+    float complex c = NUM2DBL(cr) + NUM2DBL(ci) * I;
+    float complex z = NUM2DBL(zr) + NUM2DBL(zi) * I;
+    int iteration_limit = FIX2INT(limit);
+	int i = -1;
+	int j;
+
+	for (j = 0; j < iteration_limit; j++)
+	{
+	    z = z * z + c;
+	    double a = cabs(z);
+
+	    if (a > 4.0f)
+	    {
+	        break;
+	    }
+	    
+	    i++;
+	}
+	
+	return INT2FIX(i);
+}

data/ext/infinity_check_c/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf' # for generating makefiles for Ruby extensions
+
+extension_name = 'infinity_check_c'
+dir_config(extension_name)
+create_makefile(extension_name)

data/lib/gem_with_extension_example.rb

@@ -0,0 +1,4 @@
+require 'gem_with_extension_example/base'
+require 'gem_with_extension_example/grid'
+require 'gem_with_extension_example/timer'
+require 'gem_with_extension_example/util'

data/lib/gem_with_extension_example/base.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+$:.push File.expand_path("..", __FILE__)
+
+require "version"
+require 'complex'
+
+# C extensions
+require "infinity_check_c"
+include InfinityCheckC
+
+module GemWithExtensionExample
+  class PlotFractal
+    PRETTY_PLOT = false
+
+    if PRETTY_PLOT
+      MAX_ITERATION_COUNT = 10
+    else
+      MAX_ITERATION_COUNT = 10000
+    end
+
+    DIVERGE_LIMIT = 4.0
+    DIVERGE_LIMIT_SQUARED = DIVERGE_LIMIT * DIVERGE_LIMIT
+
+    CLASSIC_JULIA_SET = Complex(-1.0,-0.25)
+
+    if PRETTY_PLOT
+      MAP_SET = " ·::++++xxxxxx "
+    else
+      MAP_SET = " · "
+    end
+
+    def self.mandelbrot(grid)
+      (0...grid.height).each do |y|
+        (0...grid.width).each do |x|
+          z = grid[x,y]
+          count = infinity_check_ruby(MAX_ITERATION_COUNT, z, z)
+          print get_render_character(count)
+        end
+        puts ""
+      end
+    end
+    def self.mandelbrot_C(grid)
+      (0...grid.height).each do |y|
+        (0...grid.width).each do |x|
+          z = grid[x,y]
+          i = z.imaginary
+          r = z.real
+          count = infinity_check_c(MAX_ITERATION_COUNT, r, i, r, i)
+          print get_render_character(count)
+        end
+        puts ""
+      end
+    end
+    def self.julia(grid)
+      (0...grid.height).each do |y|
+        (0...grid.width).each do |x|
+          z = grid[x,y]
+          i = infinity_check_ruby(MAX_ITERATION_COUNT, CLASSIC_JULIA_SET, z)
+          print get_render_character(i)
+        end
+        puts ""
+      end
+    end
+    def self.julia_C(grid)
+      (0...grid.height).each do |y|
+        (0...grid.width).each do |x|
+          z = grid[x,y]
+          count = infinity_check_c(MAX_ITERATION_COUNT, CLASSIC_JULIA_SET.real, CLASSIC_JULIA_SET.imaginary, z.real, z.imaginary)
+          print get_render_character(count)
+        end
+        puts ""
+      end
+    end
+
+    private
+    @@lookup = []
+
+    def self.build_lookup
+      limit = MAX_ITERATION_COUNT
+      step = Float(MAX_ITERATION_COUNT) / MAP_SET.length
+      MAP_SET.length.times do
+        @@lookup << Integer(limit)
+        limit -= step
+      end
+    end
+
+    self.build_lookup # populate limit table
+
+    def self.get_render_character(a)
+      c = nil
+      i = 0
+      a = MAX_ITERATION_COUNT - a
+      @@lookup.each do |limit|
+        c = MAP_SET[i]
+        i += 1
+        break if a > limit
+      end
+      return c
+    end
+
+    def self.infinity_check_ruby(limit, c, z)
+      i = -1
+      limit.times do
+        z = z * z + c
+        break if z.abs > DIVERGE_LIMIT
+        i += 1
+      end
+      return i
+    end
+  end
+end

data/lib/gem_with_extension_example/grid.rb

@@ -0,0 +1,178 @@
+require 'complex'
+
+class Grid
+  attr_reader :width, :height
+  
+  def initialize(width, height, default_value = nil)
+    @width = width
+    @height = height
+    @default_value = default_value
+    @grid = create(width, height, default_value)
+  end
+  
+  def [](x,y)
+    if (x < 0 or x >= @width) or (y < 0 or y >= @height)
+      throw Error("Grid index out of bounds. [%d][%d] not in range ([0 through %d][0 through %d])" % [x, y, width - 1, height - 1])
+    end
+    @grid[x][y]
+  end
+  
+  def []=(x,y,a)
+    if (x < 0 or x >= @width) or (y < 0 or y >= @height)
+      throw Error("Grid index out of bounds. [%d][%d] not in range ([0 through %d][0 through %d])" % [x, y, width - 1, height - 1])
+    end
+    @grid[x][y] = a
+  end
+  
+  def clear(value=nil)
+    (0...@width).each do |xi|
+      (0...@height).each do |yi|
+        @grid[xi][yi] = value
+      end
+    end
+  end
+  
+  def to_s
+    s = ""
+    @grid.each{|c| s << c.to_s << "\n"}
+    return s
+  end
+  
+  def each_col 
+    @grid.each{|c| yield c.dup} 
+  end 
+  
+  def each 
+    @grid.each do |c| 
+      c.each{|i| yield i} 
+    end 
+  end 
+
+  # Generate a two dimensional grid of float pairs, evenly
+  # distributed across width x height samples
+  # ranging from x0 to x1 and y0 to y1
+  def fill_complex(x0, y0, x1, y1)
+    x_range = x1 - x0
+    y_range = y1 - y0
+
+    width_limit = Float(@width - 1)
+    height_limit = Float(@height - 1)
+      
+    (0...@width).each do |xi|
+      x_unit = Float(xi) / width_limit
+      x = x0 + (x_unit * x_range)
+      
+      (0...@height).each do |yi|
+        y_unit = Float(yi) / height_limit
+        y = y0 + (y_unit * y_range)
+        @grid[xi][yi] = Complex(x,y)
+        #@grid[xi][yi] = [x,y]
+      end
+    end
+  end
+
+  def fill_test()
+    t = 0
+    @grid.each_with_index do |c, x| 
+      c.each_with_index{|i, y| @grid[x][y] = t; t += 1} 
+    end 
+  end
+
+  #------------------------------------------
+  private
+  
+  def create(width, height, default_value)
+    grid = Array.new(width){[]}
+    (0...width).each do |xi|
+      grid[xi] = Array.new(height, default_value)
+    end
+    return grid
+  end
+  
+end
+
+RUN_TEST = false
+
+if RUN_TEST
+  grid = Grid.new(4, 5, [0.0,0.0])
+
+  puts "-" * 9
+  p grid
+
+  puts "-" * 9
+  p grid[0,0]
+  p grid[1,1]
+
+  puts "-" * 9 
+  grid[0,0] = [5.0,2.0]
+  grid[1,1] = [7.0,9.0]
+
+  p grid[0,0]
+  p grid[1,1]
+
+  puts "-" * 9
+  p grid
+
+  puts "-" * 9
+  grid.fill_complex(-2.0, -1.0, 1.0, 1.0)
+  puts "-" * 9
+  p grid
+  
+  grid.clear(0)
+  puts "-" * 9
+  p grid
+  
+  grid.fill_test
+  puts "-" * 9
+  p grid
+  
+  puts "-" * 9
+  grid.each{|c| p c}
+  
+  puts "-" * 9
+  grid.each_col{|c| p c}
+  
+  puts "-" * 9
+  p grid
+
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/lib/gem_with_extension_example/timer.rb

@@ -0,0 +1,169 @@
+$:.push File.expand_path("..", __FILE__)
+#require 'util'
+#require File.expand_path('../util', __FILE__)
+#require '/Users/sean/dev/gems/gem_with_extension_example/lib/gem_with_extension_example/util.rb'
+
+class Timer
+  # ToDo
+  # Mode Flags:
+  #   :side_by_side (on by default)
+  #   :consecutive_runs (using redis)(off by default)
+
+  DIGITS_OF_PRESCISION = 6
+  @@max_name_length = 0
+  @@max_whole_digits = 1
+  @@timer_list = []
+  @@mode = :side_by_side
+  attr_reader :elapsed
+
+  #private :digits, :update_digit_count
+
+  def initialize(name)
+    @name = name
+    clear
+    @@max_name_length = name.length if name.length > @@max_name_length
+    @@timer_list << self
+  end
+  class << self
+    def set_mode(mode)
+      @@mode = mode #:side_by_side, :simple
+    end
+    def to_s
+      # Process pair comparison
+      pair_comparison = @@timer_list.count == 2
+      speed_multiple = nil
+      greater_index = nil
+      if pair_comparison
+        if @@timer_list[0].elapsed > @@timer_list[1].elapsed
+          greater_index = 1
+          speed_multiple = @@timer_list[0].elapsed / @@timer_list[1].elapsed
+        else
+          greater_index = 0
+          speed_multiple = @@timer_list[1].elapsed / @@timer_list[0].elapsed
+        end
+      end
+      total_time = @@timer_list.inject(0.0) { |result, t| result + t.elapsed }
+
+      # construct output string
+      s = ""
+      @@timer_list.each_with_index do |t, i|
+        s << t.to_s
+        s << "%8.3f%s" % [((t.elapsed) / total_time * 100.0), '%'] if @@timer_list.count > 1
+        if pair_comparison and (@@mode == :side_by_side) and (i == greater_index)
+          s << ", %.1f times faster." % speed_multiple
+        end
+        s << "\n"
+      end
+      if !(@@mode == :side_by_side and pair_comparison) and @@timer_list.count > 1
+        total_whole_digits = digits(total_time.to_i)
+        digit_overflow = total_whole_digits - @@max_whole_digits
+        leading_spaces = (@@max_name_length + 2) - digit_overflow
+
+        s << (" " * (@@max_name_length + 2))
+        s << ("-" * (DIGITS_OF_PRESCISION + @@max_whole_digits + 2))
+        s << "\n"
+        s << (" " * leading_spaces) if leading_spaces > 0
+        s << "%#{DIGITS_OF_PRESCISION + total_whole_digits + 1}.#{DIGITS_OF_PRESCISION}fs" % total_time
+        s << "\n"
+      end
+      s
+    end
+    def digits(n)
+      if n > 9
+        d = Math.log10(n).to_i + 1
+      elsif n < -9
+        d = Math.log10(n * -1).to_i + 1
+      else
+        d = 1
+      end
+      d
+    end
+  end
+  def clear
+    @state = :stopped
+    @time = []
+    @elapsed = 0.0
+  end
+  def self.clear
+    @@max_name_length = 0
+    @@max_whole_digits = 1
+    @@timer_list = []
+  end
+  def digits(n)
+    self.class.digits(n)
+  end
+  def update_digit_count
+    whole_digits = digits(@elapsed.to_i)
+    @@max_whole_digits = whole_digits if whole_digits > @@max_whole_digits
+  end
+  def to_s
+     "% #{@@max_name_length}s: %#{DIGITS_OF_PRESCISION + @@max_whole_digits + 1}.#{DIGITS_OF_PRESCISION}fs" % [@name, @elapsed]
+  end
+  def +(o)
+    o = o.elapsed if o.is_a?(self.class)
+    @elapsed += o
+    update_digit_count
+  end
+  def /(o)
+    o = o.elapsed if o.is_a?(self.class)
+    @elapsed /= o
+    update_digit_count
+  end
+  def start
+    if @state == :stopped
+      @state = :running
+      @start = Time.now
+    end
+  end
+  def stop
+    if @state == :running
+      stop = Time.now
+      @elapsed += (stop - @start)
+      update_digit_count
+      @state = :stopped
+    end
+  end
+end
+
+if __FILE__ == $0
+  #Timer.set_mode(:simple)
+  19.times do
+    test_count = Random.rand(4) + 1
+    timer_list = []
+
+    # Allocate Timers
+    test_count.times do |n|
+      timer_name = ("A".ord + n).chr
+      timer_list[n] = Timer.new(timer_name)
+    end
+
+    # Use Timers
+    test_count.times do |n|
+      timer_list[n].start
+      timer_list[n].stop
+      timer_list[n] += Random.rand * 133 # fake out the timer
+    end
+
+    # Show Timers
+    puts ""
+    puts Timer
+    Timer.clear
+  end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/lib/gem_with_extension_example/version.rb

@@ -0,0 +1,9 @@
+module GemWithExtensionExample
+  # Use semantic versioning: http://semver.org/
+
+  # PATCH 0.0.x level changes for implementation level detail changes, such as small bug fixes
+  # MINOR 0.x.0 level changes for any backwards compatible API changes, such as new functionality/features
+  # MAJOR x.0.0 level changes for backwards incompatible
+
+  VERSION = "0.0.0"
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: gem_with_extension_example
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Sean Vikoren
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-10 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: &2165428740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2165428740
+description: This gem is intended to function as a starting point for developing gems
+  that contain C optimizations.
+email:
+- sean@vikoren.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ext/infinity_check_c/InfinityCheckC.c
+- ext/infinity_check_c/extconf.rb
+- lib/gem_with_extension_example/base.rb
+- lib/gem_with_extension_example/grid.rb
+- lib/gem_with_extension_example/timer.rb
+- lib/gem_with_extension_example/version.rb
+- lib/gem_with_extension_example.rb
+- lib/gem_with_extension_example/infinity_check_c.bundle
+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: gem_with_extension_example
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: An example gem with a C extention.
+test_files: []