integration 0.1.0

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,3 @@
+=== 0.1.0 / 2011-08-23
+
+* Get code from http://rubyforge.org/projects/integral/ and converted to a gem.

data/Manifest.txt

@@ -0,0 +1,9 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/integration.rb
+spec/integration_spec.rb
+spec/spec.opts
+spec/spec_helper.rb

data/README.txt

@@ -0,0 +1,60 @@
+= integration
+
+* http://github.com/clbustos/integration
+
+== DESCRIPTION:
+
+Numerical integration for Ruby, with a simple interface
+
+== FEATURES/PROBLEMS:
+
+* Use only one method: Integration.integrate
+* Rectangular, Trapezoidal, Simpson, Adaptive quadrature, Monte Carlo and Romberg integration methods available on pure Ruby. 
+* If available, uses Ruby/GSL QNG non-adaptive Gauss-Kronrod integration and QAG adaptive integration, with support for Infinity+ and Infinity- 
+
+
+== SYNOPSIS:
+
+  Integration.integrate(1,2,{:tolerance=>1e-10,:method=>:simpson}) {|x| x**2} => 2.333333
+  
+  # Support for infinity bounds with GSL QAG adaptative integration
+  
+  normal_pdf=lambda {|x| (1/Math.sqrt(2*Math::PI))*Math.exp(-(x**2/2))}
+  Integration.integrate(Integration::MInfinity, 0 , {:tolerance=>1e-10}, &normal_pdf) => 0.5
+  Integration.integrate(0, Integration::Infinity , {:tolerance=>1e-10}, &normal_pdf) => 0.5
+  
+== REQUIREMENTS:
+
+* Ruby/GSL, for better performance and support for infinite bounds
+
+== INSTALL:
+
+  gem install integration
+  
+== LICENSE:
+
+    Copyright (c) 2005  Beng
+                  2011  clbustos
+    
+    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 DEVELOPERS 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.
+    
+    Except as contained in this notice, the name of the Beng shall not
+    be used in advertising or otherwise to promote the sale, use or other dealings
+    in this Software without prior written authorization from Beng.
+

data/Rakefile

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+$:.unshift(File.expand_path(File.dirname(__FILE__)+"/lib/"))
+require 'rubygems'
+require 'hoe'
+require 'integration'
+require 'rubyforge'
+# Hoe.plugin :compiler
+# Hoe.plugin :gem_prelude_sucks
+ Hoe.plugin :git
+# Hoe.plugin :inline
+# Hoe.plugin :racc
+# Hoe.plugin :rubyforge
+
+Hoe.spec 'integration' do
+  self.developer('Ben Gimpert', 'NO_EMAIL')
+  self.developer('Claudio Bustos', 'clbustos_at_gmail.com')
+  self.version=Integration::VERSION
+  self.extra_dev_deps << ["rspec",">=2.0"] << ["rubyforge",">=0"]
+
+end
+# git log --pretty=format:"*%s[%cn]" v0.5.0..HEAD >> History.txt
+# vim: syntax=ruby
+

data/lib/integration.rb

@@ -0,0 +1,340 @@
+# Copyright (c) 2005  Beng (original code)
+#               2011  clbustos
+# 
+# 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 X CONSORTIUM 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.
+# 
+# Except as contained in this notice, the name of the Beng shall not
+# be used in advertising or otherwise to promote the sale, use or other dealings
+# in this Software without prior written authorization from Beng.
+
+# Diverse integration methods
+# Use Integration.integrate as wrapper to direct access to methods
+# 
+# Method API 
+#
+
+class Integration
+  VERSION = '0.1.0'
+  # Minus Infinity
+  MInfinity=:minfinity
+  # Infinity
+  Infinity=:infinity
+  class << self
+    
+    # Create a method 'has_<library>' on Module
+    # which require a library and return true or false
+    # according to success of failure 
+    def create_has_library(library) #:nodoc:
+      define_singleton_method("has_#{library}?") do
+        cv="@@#{library}"
+        if !class_variable_defined? cv
+          begin 
+            require library.to_s
+            class_variable_set(cv, true)
+          rescue LoadError
+            class_variable_set(cv, false)
+          end
+        end
+        class_variable_get(cv)
+      end
+    end
+    
+    # Rectangle method
+    # +n+ implies number of subdivisions
+    def rectangle(t1, t2, n)
+      total_area = 0
+      t = t1
+      dt = (t2 - t1) / n.to_f
+      dt_half = dt / 2
+      
+      while (t + dt_half) <= t2
+      height = yield(t + dt_half)
+      area = dt * height
+      total_area += area
+      t += dt
+      end
+      return total_area
+
+    end
+    alias_method :midpoint, :rectangle
+  
+    def trapezoid(t1, t2, n)
+      total_area = 0
+      t = t1
+      dt = (t2 - t1) / n.to_f
+      prev_height = nil
+      while (t + dt) <= t2
+        if prev_height.nil?
+          height1 = yield(t)
+        else
+          height1 = prev_height
+        end
+        height2 = yield(t + dt)
+        area = dt * ((height1 + height2) / 2)
+        total_area += area
+        t += dt
+        prev_height = height2
+      end
+      return total_area
+    end
+  
+    def simpson(t1, t2, n)
+      n += 1 unless n % 2 == 0
+      dt = (t2.to_f - t1) / n
+      total_area = 0
+      (0..n).each do |i|
+        t = t1 + (dt * i)
+        if i.zero? || (i == n)
+          total_area += yield(t)
+        elsif i % 2 == 0
+          total_area += 2 * yield(t)
+        else
+          total_area += 4 * yield(t)
+        end
+      end
+      total_area *= dt / 3
+      return total_area
+    end
+  
+    def adaptive_quadrature(a, b, tolerance)
+      h = (b.to_f - a) / 2
+      fa = yield(a)
+      fc = yield(a + h)
+      fb = yield(b)
+      s = h * (fa + (4 * fc) + fb) / 3
+      helper = Proc.new { |a, b, fa, fb, fc, h, s, level|
+        if level < 1/tolerance.to_f
+          fd = yield(a + (h / 2))
+          fe = yield(a + (3 * (h / 2)))
+          s1 = h * (fa + (4.0 * fd) + fc) / 6
+          s2 = h * (fc + (4.0 * fe) + fb) / 6
+          if ((s1 + s2) - s).abs <= tolerance
+            s1 + s2
+          else
+            helper.call(a, a + h, fa, fc, fd, h / 2, s1, level + 1) +
+            helper.call(a + h, b, fc, fb, fe, h / 2, s2, level + 1)
+          end
+        else
+          raise "Integral did not converge"
+        end
+      }
+      return helper.call(a, b, fa, fb, fc, h, s, 1)
+    end
+  
+    def gauss(t1, t2, n)
+      case n
+        when 1
+          z = [0.0]
+          w = [2.0]
+        when 2
+          z = [-0.57735026919, 0.57735026919]
+          w = [1.0, 1.0]
+        when 3
+          z = [-0.774596669241, 0.0, 0.774596669241]
+          w = [0.555555555556, 0.888888888889, 0.555555555556]
+        when 4
+          z = [-0.861136311594, -0.339981043585, 0.339981043585, 0.861136311594]
+          w = [0.347854845137, 0.652145154863, 0.652145154863, 0.347854845137]
+        when 5
+          z = [-0.906179845939, -0.538469310106, 0.0, 0.538469310106, 0.906179845939]
+          w = [0.236926885056, 0.478628670499, 0.568888888889, 0.478628670499, 0.236926885056]
+        when 6
+          z = [-0.932469514203, -0.661209386466, -0.238619186083, 0.238619186083, 0.661209386466, 0.932469514203]
+          w = [0.171324492379, 0.360761573048, 0.467913934573, 0.467913934573, 0.360761573048, 0.171324492379]
+        when 7
+          z = [-0.949107912343, -0.741531185599, -0.405845151377, 0.0, 0.405845151377, 0.741531185599, 0.949107912343]
+          w = [0.129484966169, 0.279705391489, 0.381830050505, 0.417959183673, 0.381830050505, 0.279705391489, 0.129484966169]
+        when 8
+          z = [-0.960289856498, -0.796666477414, -0.525532409916, -0.183434642496, 0.183434642496, 0.525532409916, 0.796666477414, 0.960289856498]
+          w = [0.10122853629, 0.222381034453, 0.313706645878, 0.362683783378, 0.362683783378, 0.313706645878, 0.222381034453, 0.10122853629]
+        when 9
+          z = [-0.968160239508, -0.836031107327, -0.613371432701, -0.324253423404, 0.0, 0.324253423404, 0.613371432701, 0.836031107327, 0.968160239508]
+          w = [0.0812743883616, 0.180648160695, 0.260610696403, 0.31234707704, 0.330239355001, 0.31234707704, 0.260610696403, 0.180648160695, 0.0812743883616]
+        when 10
+          z = [-0.973906528517, -0.865063366689, -0.679409568299, -0.433395394129, -0.148874338982, 0.148874338982, 0.433395394129, 0.679409568299, 0.865063366689, 0.973906528517]
+          w = [0.0666713443087, 0.149451349151, 0.219086362516, 0.26926671931, 0.295524224715, 0.295524224715, 0.26926671931, 0.219086362516, 0.149451349151, 0.0666713443087]
+        else
+          raise "Invalid number of spaced abscissas #{n}, should be 1-10"
+      end
+      sum = 0
+      (0...n).each do |i|
+        t = ((t1.to_f + t2) / 2) + (((t2 - t1) / 2) * z[i])
+        sum += w[i] * yield(t)
+      end
+      return ((t2 - t1) / 2.0) * sum
+    end
+  
+    def romberg(a, b, tolerance)
+      # NOTE one-based arrays are used for convenience
+      
+      h = b.to_f - a
+      m = 1
+      close = 1
+      r = [[], [], [], [], [], [], [], [], [], [], [], [], []];
+      r[1][1] = (h / 2) * (yield(a) + yield(b))
+      j = 1
+      while j <= 11 && tolerance < close
+        j += 1
+        r[j][0] = 0
+        h /= 2
+        sum = 0
+        (1..m).each do |k|
+          sum += yield(a + (h * ((2 * k) - 1)))
+        end
+        m *= 2
+        r[j][1] = r[j-1][1] / 2 + (h * sum)
+        (1..j-1).each do |k|
+          r[j][k+1] = r[j][k] + ((r[j][k] - r[j-1][k]) / ((4 ** k) - 1))
+        end
+        close = (r[j][j] - r[j-1][j-1])
+      end
+      return r[j][j]
+    end
+  
+    def monte_carlo(t1, t2, n)
+      width = (t2 - t1).to_f
+      height = nil
+      vals = []
+      n.times do
+        t = t1 + (rand() * width)
+        ft = yield(t)
+        height = ft if height.nil? || ft > height
+        vals << ft
+      end
+      area_ratio = 0
+      vals.each do |ft|
+        area_ratio += (ft / height.to_f) / n.to_f
+      end
+      return (width * height) * area_ratio
+    end
+    def is_infinite?(v)
+      v==Infinity or v==MInfinity
+    end
+    # Methods available on pure ruby
+    RUBY_METHOD=[:rectangle,:trapezoid,:simpson, :adaptive_quadrature , :gauss, :romberg, :monte_carlo]
+    # Methods available with Ruby/GSL library
+    GSL_METHOD=[:qng, :qag]
+    # Get the integral for a function +f+, with bounds +t1+ and
+    # +t2+ given a hash of +options+. 
+    # If Ruby/GSL is available, you could use +Integration::Minfinity+
+    # and +Integration::Infinity+ as bounds. Method
+    # Options are
+    # [:tolerance]    Maximum difference between real and calculated integral.
+    #                 Default: 1e-10
+    # [:initial_step] Initial number of subdivitions
+    # [:step]         Subdivitions increment on each iteration
+    # [:method]       Integration method. 
+    # Methods are
+    # [:rectangle] for [:initial_step+:step*iteration] quadrilateral subdivisions
+    # [:trapezoid] for [:initial_step+:step*iteration] trapezoid-al subdivisions
+    # [:simpson]   for [:initial_step+:step*iteration] parabolic subdivisions
+    # [:adaptive_quadrature] for recursive appoximations until error [tolerance]
+    # [:gauss] [:initial_step+:step*iteration] weighted subdivisons using translated -1 -> +1 endpoints
+    # [:romberg] extrapolation of recursion approximation until error < [tolerance]
+    # [:monte_carlo] make [:initial_step+:step*iteration] random samples, and check for above/below curve
+    # [:qng] GSL QNG non-adaptive Gauss-Kronrod integration
+    # [:qag] GSL QAG adaptive integration, with support for infinite bounds
+    def integrate(t1,t2,options=Hash.new, &f)
+      inf_bounds=(is_infinite?(t1) or is_infinite?(t2))
+      raise "No function passed" unless block_given?
+      raise "Non-numeric bounds" unless ((t1.is_a? Numeric) and (t2.is_a? Numeric)) or inf_bounds
+      if(inf_bounds)
+        lower_bound=t1
+        upper_bound=t2
+        options[:method]=:qag if options[:method].nil?
+      else 
+        lower_bound = [t1, t2].min
+        upper_bound = [t1, t2].max
+      end
+      def_method=(has_gsl?) ? :qag : :simpson
+      default_opts={:tolerance=>1e-10, :initial_step=>16,:step=>16, :method=>def_method}
+      options=default_opts.merge(options)
+      if RUBY_METHOD.include? options[:method]
+        raise "Ruby methods doesn't support infinity bounds" if inf_bounds
+        integrate_ruby(lower_bound,upper_bound,options,&f)
+      elsif GSL_METHOD.include? options[:method]
+        integrate_gsl(lower_bound,upper_bound,options,&f)
+      else
+        raise "Unknown integration method \"#{options[:method]}\""
+      end
+    end
+    def integrate_gsl(lower_bound,upper_bound,options,&f) 
+      
+      f = GSL::Function.alloc(&f)
+      method=options[:method]
+      tolerance=options[:tolerance]
+     
+      if(method==:qag)
+        w = GSL::Integration::Workspace.alloc()
+        if(is_infinite?(lower_bound) and  is_infinite?(upper_bound))        
+          #puts "ambos"
+          val=f.qagi([tolerance,0.0], 1000, w)  
+        elsif is_infinite?(lower_bound)
+          #puts "inferior #{upper_bound}"
+          val=f.qagil(upper_bound, [tolerance, 0], w) 
+        elsif is_infinite?(upper_bound)
+          #puts "superior"
+          val=f.qagiu(lower_bound, [tolerance, 0], w)
+        else
+          
+          val=f.qag([lower_bound,upper_bound],[tolerance,0.0], GSL::Integration::GAUSS61, w)
+        end
+      elsif(method==:qng)
+        val=f.qng([lower_bound, upper_bound], [tolerance, 0.0]) 
+      else
+        raise "Unknown integration method \"#{method}\""
+      end
+      val[0]
+    end
+    def integrate_ruby(lower_bound,upper_bound,options,&f)
+      method=options[:method]
+      tolerance=options[:tolerance]
+      initial_step=options[:initial_step]
+      step=options[:step]
+      
+      begin
+        method_obj = Integration.method(method.to_s.downcase)
+      rescue
+        raise "Unknown integration method \"#{method}\""
+      end
+      current_step=initial_step
+
+      if(method==:adaptive_quadrature or method==:romberg  or method==:gauss)
+        if(method==:gauss)
+          initial_step=10 if initial_step>10
+          tolerance=initial_step
+        end
+        method_obj.call(lower_bound, upper_bound, tolerance, &f)
+      else
+        #puts "iniciando"
+        value=method_obj.call(lower_bound, upper_bound, current_step, &f)
+        previous=value+(tolerance*2)
+        while((previous-value).abs > tolerance) do
+          #puts(value)
+          #puts(current_step)
+          current_step+=step
+          previous=value
+          value=method_obj.call(lower_bound, upper_bound, current_step, &f)
+        end
+        value
+      end
+    end
+  end
+  create_has_library :gsl
+end

data/spec/integration_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
+describe Integration do
+  it "should respond integration based on ruby methods" do
+    a=lambda {|x| x**2}
+    # Integration over [1,2]=x^3/3=7/3
+    
+    methods=[:rectangle,:trapezoid, :simpson, :adaptive_quadrature,  :romberg]
+    methods.each do |m|
+      Integration.integrate(1,2,{:method=>m,:tolerance=>1e-7},&a).should be_within(1e-6).of(7/3.0)
+    end
+
+  end
+  
+  it "should return a correct value for a complex integration with ruby methods" do
+    normal_pdf=lambda {|x| (1/Math.sqrt(2*Math::PI))*Math.exp(-(x**2/2))}
+    Integration.integrate(0,1,{:tolerance=>1e-12,:method=>:simpson},&normal_pdf).should be_within(1e-11).of(0.341344746068)
+    Integration.integrate(0,1,{:tolerance=>1e-12,:method=>:adaptive_quadrature},&normal_pdf).should be_within(1e-11).of(0.341344746068)
+  end
+  it "should return a correct value for a complex integration with gsl methods" do
+    normal_pdf=lambda {|x| (1/Math.sqrt(2*Math::PI))*Math.exp(-(x**2/2))}
+    Integration.integrate(0,1,{:tolerance=>1e-12,:method=>:qng},&normal_pdf).should be_within(1e-11).of(0.341344746068)
+    Integration.integrate(0,1,{:tolerance=>1e-12,:method=>:qag},&normal_pdf).should be_within(1e-11).of(0.341344746068)
+  end
+
+      
+  it "should return correct integration for infinity bounds" do
+    if Integration.has_gsl?
+      normal_pdf=lambda {|x| (1/Math.sqrt(2*Math::PI))*Math.exp(-(x**2/2))}
+
+      Integration.integrate(Integration::MInfinity, Integration::Infinity,{:tolerance=>1e-10}, &normal_pdf).should be_within(1e-09).of(1)
+    else
+      pending("GSL not available")
+    end
+  end
+  it "should return correct integration for infinity lower bound" do
+    if Integration.has_gsl?
+      normal_pdf=lambda {|x| (1/Math.sqrt(2*Math::PI))*Math.exp(-(x**2/2))}
+
+      Integration.integrate(Integration::MInfinity, 0 , {:tolerance=>1e-10}, &normal_pdf).should be_within(1e-09).of(0.5)
+
+    else
+      pending("GSL not available")
+    end
+  end
+ it "should return correct integration for infinity upper bound" do
+    if Integration.has_gsl?
+
+      normal_pdf=lambda {|x| (1/Math.sqrt(2*Math::PI))*Math.exp(-(x**2/2))}
+      Integration.integrate(0,Integration::Infinity,{:tolerance=>1e-10}, &normal_pdf).should be_within(1e-09).of(0.5)
+
+    else
+      pending("GSL not available")
+    end
+  end
+  it "should raise an error if a ruby methods is called with infinite bounds" do
+    normal_pdf=lambda {|x| (1/Math.sqrt(2*Math::PI))*Math.exp(-(x**2/2))}
+    lambda {Integration.integrate(0,Integration::Infinity,{:method=>:simpson}, &normal_pdf).should be_within(1e-09).of(0.5)}.should raise_exception()
+  end
+end
+

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--color
+-f s
+-b

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+$:.unshift(File.dirname(__FILE__)+"/../lib")
+begin
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "/spec/"
+    add_group "Libraries", "lib"
+  end
+rescue LoadError
+end
+require 'rspec'
+require 'integration'

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification 
+name: integration
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Ben Gimpert
+- Claudio Bustos
+autorequire: 
+bindir: bin
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDMjCCAhqgAwIBAgIBADANBgkqhkiG9w0BAQUFADA/MREwDwYDVQQDDAhjbGJ1
+  c3RvczEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPyLGQBGRYDY29t
+  MB4XDTEwMDMyOTIxMzg1NVoXDTExMDMyOTIxMzg1NVowPzERMA8GA1UEAwwIY2xi
+  dXN0b3MxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixkARkWA2Nv
+  bTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALf8JVMGqE7m5kYb+PNN
+  neZv2pcXV5fQCi6xkyG8bi2/SIFy/LyxuvLzEeOxBeaz1Be93bayIUquOIqw3dyw
+  /KXWa31FxuNuvAm6CN8fyeRYX/ou4cw3OIUUnIvB7RMNIu4wbgeM6htV/QEsNLrv
+  at1/mh9JpqawPrcjIOVMj4BIp67vmzJCaUf+S/H2uYtSO09F+YQE3tv85TPeRmqU
+  yjyXyTc/oJiw1cXskUL8UtMWZmrwNLHXuZWWIMzkjiz3UNdhJr/t5ROk8S2WPznl
+  0bMy/PMIlAbqWolRn1zl2VFJ3TaXScbqImY8Wf4g62b/1ZSUlGrtnLNsCYXrWiso
+  UPUCAwEAAaM5MDcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0OBBYEFGu9
+  rrJ1H64qRmNNu3Jj/Qjvh0u5MA0GCSqGSIb3DQEBBQUAA4IBAQCV0Unka5isrhZk
+  GjqSDqY/6hF+G2pbFcbWUpjmC8NWtAxeC+7NGV3ljd0e1SLfoyBj4gnFtFmY8qX4
+  K02tgSZM0eDV8TpgFpWXzK6LzHvoanuahHLZEtk/+Z885lFene+nHadkem1n9iAB
+  cs96JO9/JfFyuXM27wFAwmfHCmJfPF09R4VvGHRAvb8MGzSVgk2i06OJTqkBTwvv
+  JHJdoyw3+8bw9RJ+jLaNoQ+xu+1pQdS2bb3m7xjZpufml/m8zFCtjYM/7qgkKR8z
+  /ZZt8lCiKfFArppRrZayE2FVsps4X6WwBdrKTMZ0CKSXTRctbEj1BAZ67eoTvBBt
+  rpP0jjs0
+  -----END CERTIFICATE-----
+
+date: 2011-08-24 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "2.0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.12"
+  type: :development
+  version_requirements: *id003
+description: Numerical integration for Ruby, with a simple interface
+email: 
+- NO_EMAIL
+- clbustos_at_gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- .autotest
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/integration.rb
+- spec/integration_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- .gemtest
+has_rdoc: true
+homepage: http://github.com/clbustos/integration
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+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: integration
+rubygems_version: 1.6.0
+signing_key: 
+specification_version: 3
+summary: Numerical integration for Ruby, with a simple interface
+test_files: []
+

metadata.gz.sig

@@ -0,0 +1 @@
+�mV݈5�H�Ȗ�279s�Z�Q�eY�ڇ&����9CKy��*�p�����z�"��m�<����/��_��[!�6��a$mzj6`��Z���0��6��S