integrator 0.0.1 → 0.0.2

data/README.txt

@@ -1,3 +1,13 @@
 This gem includes a framework for numerical integrators, both fixed-step and
 adaptive, and includes an excellent sample integrator of each type to get
 you started.
+
+It's faster to write such things in C or C++, but better for
+portability to keep it in Ruby.  I'm using Ruby vector operations
+rather than iterating manually so that at least the scalability isn't
+too bad...
+
+The Cash-Karp embedded Runge-Kutta 4/5 integrator's code is adapted
+from the code in chapter 16 of "Numerical Recipes in C", second
+edition.  Adapting this stuff to Ruby and to OO operation is all done
+ad-hoc and by me.

data/lib/integrator.rb

@@ -24,7 +24,7 @@ module Integrator
     @count = 0
   end
 
-  private
+  protected
 
   def set_adaptive_sample_count(count, num_ok)
     @count = count

data/lib/integrator/adaptive.rb

@@ -11,20 +11,18 @@ require "matrix"
 require "rubygems"
 require "integrator"
 
-require "integrator/rkqs.rb"
-
-# This is the top-level driver, with logging, for Cash-Karp adaptive
-# Runge-Kutta fourth-order integration with error checking.  The
-# algorithm is from "Numerical Methods in C", second edition.
-
-class Adaptive_Cash_Karp_RK45 < OneStep_Cash_Karp_RK45
+# This is the top-level driver, with logging, used by the more complex
+# integrators in "Numerical Methods in C", second edition.  Code is
+# adapted from C, of course.
+#
+module AdaptiveIntegrator
   include Integrator
 
   MAXSTP = 10000
   TINY = 1.0e-30
 
-  def initialize()
-    Integrator_initialize()
+  def integrate_ad_step(y, dydx, x, h, eps, yscal, derivs)
+    raise "Adaptive integrators must implement integrate_ad_step!"
   end
 
   def adaptive_integrate(ystart, x1, x2, eps, h1, hmin, derivs)
@@ -77,33 +75,4 @@ class Adaptive_Cash_Karp_RK45 < OneStep_Cash_Karp_RK45
     raise "Too many steps in integration!"
   end
 
-end
-
-if __FILE__ == $0
-
-  rk45 = Adaptive_Cash_Karp_RK45.new()
-
-  def assert_within_epsilon(actual, expected)
-    if expected.kind_of?(Vector)
-      actual.collect2(expected) { |x, y|
-	assert_within_epsilon(x, y)
-      }
-    else
-      (actual - expected).abs / expected < 0.001 or
-	raise "Values don't match!  Actual was #{actual}, not #{expected}!"
-    end
-  end
-  assert_within_epsilon(10000.0, 10001)
-
-  # This takes the derivative of e^x for each vector element.
-  # The derivative of e^x is just e^x again.
-  exp_deriv = proc { |x, y| y.collect { |yi| yi } }
-
-  exp_start = Vector.elements([1.0] * 100)
-
-  y = rk45.adaptive_integrate(exp_start, 0.0, 1.0, 0.001, 0.01, 0.0001,
-			      exp_deriv)
-  assert_within_epsilon(y, Vector.elements( [ Math::E ] * 100 ))
-
-  print "All tests completed...\n"
-end
+end # module AdaptiveIntegrator

data/lib/integrator/rkck.rb

@@ -15,6 +15,8 @@
 require "matrix"
 
 class Cash_Karp_RK4
+  include Integrator
+
   A2 = 0.2
   A3 = 0.3
   A4 = 0.6
@@ -45,6 +47,10 @@ class Cash_Karp_RK4
   DC5 = -277.00/14336.0
   DC6 = C6-0.25
 
+  def initialize
+    Integrator_initialize()
+  end
+
   def integrate_fixed_step(y, dydx, x, h, derivs)
     raise "Bad type!" unless [y, dydx].all? { |var| var.kind_of?(Vector) }
     raise "Bad type!" unless [x, h].all? { |var| var.kind_of?(Float) }
@@ -68,46 +74,3 @@ class Cash_Karp_RK4
     [yout, yerr]
   end
 end
-
-if __FILE__ == $0
-
-  def assert_within_epsilon(actual, expected)
-    if expected.kind_of?(Vector)
-      expected.collect2(actual) { |x, y|
-	assert_within_epsilon(x, y)
-      }
-    else
-      (actual - expected).abs / expected < 0.001 or
-	raise "Values don't match!  Actual was #{actual}, not #{expected}!"
-    end
-  end
-  assert_within_epsilon(10000.0, 10000.00001)
-
-  const_deriv = proc do |x, y|
-    y.collect { |yi| 0.1 }
-  end
-
-  exp_deriv = proc do |x, y|
-    y.collect { |yi| yi }
-  end
-
-  integ = Cash_Karp_RK4.new()
-
-  constvec = Vector.elements([1.0] * 100)
-  constderiv = const_deriv.call(0, constvec)
-
-  # Integrate a constant derivative over a distance of 1.0
-  yout, yerr = integ.integrate_fixed_step(constvec, constderiv, 0.0, 1.0,
-			                  const_deriv)
-  assert_within_epsilon(yout, Vector.elements([ 1.1 ] * 100))
-
-  onevec = Vector.elements([1.0] * 100)
-  expderiv = exp_deriv.call(0, onevec)
-  dist = 0.01 # Keep this small because we only make one integration step
-  # Integrate e^x over a distance of 1.0, starting at e^0 == 1.0
-  yout, yerr = integ.integrate_fixed_step(onevec, expderiv, 0.0, dist,
-			                  exp_deriv)
-  assert_within_epsilon(yout, Vector.elements([ Math::E ** dist ] * 100))
-
-  print "Tests completed...\n"
-end

data/lib/integrator/rkqs.rb

@@ -9,9 +9,12 @@
 #
 
 require "matrix"
-require "integrator/rkck.rb"
+require "integrator/rkck"
+require "integrator/adaptive"
+
+class Adaptive_Cash_Karp_RK45 < Cash_Karp_RK4
+  include AdaptiveIntegrator
 
-class OneStep_Cash_Karp_RK45 < Cash_Karp_RK4
   SAFETY = 0.9
   PGROW = -0.2
   PSHRNK = -0.25
@@ -45,7 +48,3 @@ class OneStep_Cash_Karp_RK45 < Cash_Karp_RK4
   end
 
 end
-
-if __FILE__ == $0
-
-end

data/lib/integrator/version.rb

@@ -2,7 +2,7 @@ module Integrator #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 0
-    TINY  = 1
+    TINY  = 2
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/test_helper.rb

@@ -1,2 +1,2 @@
 require 'test/unit'
-require File.dirname(__FILE__) + '/../lib/integrator'
+#require File.dirname(__FILE__) + '/../lib/integrator'

data/test/test_integrator.rb

@@ -1,11 +1,65 @@
 require File.dirname(__FILE__) + '/test_helper.rb'
+require 'integrator/adaptive.rb'
+require 'integrator/rkck.rb'
+require 'integrator/rkqs.rb'
 
 class TestIntegrator < Test::Unit::TestCase
 
   def setup
+    # Test both fixed-step and adaptive integrators
+    @fixed_integrator = Cash_Karp_RK4.new()
+    @ad_integrator = Adaptive_Cash_Karp_RK45.new()
   end
-  
-  def test_truth
-    assert true
+
+  def assert_within_epsilon(actual, expected)
+    if expected.kind_of?(Vector)
+      expected.collect2(actual) { |x, y|
+	assert_within_epsilon(x, y)
+      }
+    else
+      (actual - expected).abs / expected < 0.001 or
+	raise "Values don't match!  Actual was #{actual}, not #{expected}!"
+    end
+  end
+
+  def test_a_w_e
+    assert_within_epsilon(10000.0, 10000.00001)
+    assert_within_epsilon(10000.0, 10001)
+  end
+
+  def test_const_func
+    const_deriv_proc = proc do |x, y|
+      y.collect { |yi| 0.1 }
+    end
+    constvec = Vector.elements([1.0] * 100)
+    constderiv = const_deriv_proc.call(0, constvec)
+
+    # Integrate a constant derivative over a distance of 1.0
+    yout, yerr = @fixed_integrator.integrate_fixed_step(constvec, constderiv,
+							0.0, 1.0,
+							const_deriv_proc)
+    assert_within_epsilon(yout, Vector.elements([ 1.1 ] * 100))
   end
+
+  def test_exp_func
+    # This takes the derivative of e^x for each vector element.
+    # The derivative of e^x is just e^x again.
+    exp_deriv_proc = proc do |x, y|
+      y.collect { |yi| yi }
+    end
+
+    onevec = Vector.elements([1.0] * 100)
+    expderiv = exp_deriv_proc.call(0, onevec)
+    dist = 0.01 # Keep this small because we only make one integration step
+    # Integrate e^x over a distance of 1.0, starting at e^0 == 1.0
+    yout, yerr = @fixed_integrator.integrate_fixed_step(onevec, expderiv,
+							0.0, dist,
+							exp_deriv_proc)
+    assert_within_epsilon(yout, Vector.elements([ Math::E ** dist ] * 100))
+
+    y = @ad_integrator.adaptive_integrate(onevec, 0.0, 1.0, 0.001, 0.01,
+					  0.0001, exp_deriv_proc)
+    assert_within_epsilon(y, Vector.elements( [ Math::E ] * 100 ))
+  end
+
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: integrator
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
-date: 2007-10-14 00:00:00 -07:00
+  version: 0.0.2
+date: 2007-10-15 00:00:00 -07:00
 summary: Numerical integration framework
 require_paths: 
 - lib