rb-daspk 0.0.2-x86-darwin-10

data/lib/rb-daspk.rb

@@ -0,0 +1,294 @@
+# Copyright (c) 2009 Eric Todd Meyers
+#
+# 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.
+#
+#
+# More information, source code and gems @ http://rubyforge.org/projects/rb-daspk/
+#
+#
+
+require 'rubygems'
+require 'ffi'
+
+module FFI
+  class Pointer
+    def read_double
+      get_float64(0)
+    end
+
+    def write_double(obj)
+      put_float64(0, obj)
+    end
+
+    def read_array_of_double(length)
+      get_array_of_double(0, length)
+    end
+
+    def write_array_of_double(ary)
+      put_array_of_double(0, ary)
+    end
+  end
+end
+
+
+module DASPK
+ extend FFI::Library
+ ffi_lib File.dirname(__FILE__) +  '/libdaspk.dylib'
+ callback :jac, [:pointer,:pointer,:pointer,:pointer,:pointer,:pointer,:pointer], :void
+ callback :res, [:pointer,:pointer,:pointer,:pointer,:pointer,:pointer,:pointer,:pointer], :void
+ attach_function 'ddaspk_', [:res,    :pointer,:pointer,:pointer,:pointer,:pointer,:pointer,:pointer,:pointer,:pointer, 
+                             :pointer,:pointer,:pointer,:pointer,:pointer,:pointer,:jac,    :pointer], :void
+#
+#
+#  interface to DASPK
+#                             
+#  typical usage
+#   
+#  1. create an instance of the Solver class. pass in the initial states/derivatives and the residual function as a block
+#  2. if the initial conditions are not consistent call solveForInitialValues
+#  3. call solve with the start and end times desired
+#  4. repeated calls to solve will solve to each end time. the start time is ingored. this allows
+#     for continued integration
+#
+ class Solver
+
+    include DASPK
+
+    attr_accessor :rtol,:atol,:init,:jac,:maxstep
+#
+#
+# * neq    = the number of equations. this is always the sum of the number of states and algebraics
+# * y      = array containing the initial states and algebraics
+# * yprime = array containing the initial state derivatives
+# * inter  = Proc instance. defaults to nil. if non-nil used as a callback to report the integration results at every time step
+# * jac    = Proc instance. defauls to nil. if non-nil used to get the modified Jacbian matrix. otherwise DASPK will determine by iteration
+# * res    = residual (delta) Proc. must be present. this is responsible for filling of the delta (residual) array. 
+#
+    def initialize (neq, y, yprime, inter=nil, jac=nil, &res)
+       @lwr   = 15000
+       @lwi   = 15000
+       @plwr  = FFI::MemoryPointer.new(:int)
+       @plwr.write_int(@lwr)
+       @plwi  = FFI::MemoryPointer.new(:int)
+       @plwi.write_int(@lwi)
+       @iwork = [0]*@lwi
+       @work  = [0]*@lwr
+       @pwork = FFI::MemoryPointer.new(:double,@lwr)
+       @piwork = FFI::MemoryPointer.new(:int,@lwi)
+       @info = [0]*30
+       @pinfo  = FFI::MemoryPointer.new(:int,30)
+       @ialgs = [1]*neq
+       @res = res
+       @inter = inter
+       @rtol = 0.000001
+       @atol = 0.000001
+       @jac  = jac
+       @maxstep =0
+       @init = 0
+
+       if (inter) then
+         @info[2]=1
+       end
+
+       @neq = neq
+       @pneq  = FFI::MemoryPointer.new(:int)
+       @pneq.write_int(neq)
+       @y=y
+       @yprime=yprime
+
+       @py       = FFI::MemoryPointer.new(:double,neq)
+       @py.write_array_of_double(y)
+       @pyprime  = FFI::MemoryPointer.new(:double,neq)
+       @pyprime.write_array_of_double(yprime)
+
+       @prtol  = FFI::MemoryPointer.new(:double)
+       @patol  = FFI::MemoryPointer.new(:double)
+
+#
+#  residual proc called from the Fortran. Let's pass it onto the user's residual procedure
+#  in a easier to use form
+#
+       @resproc = Proc.new do |p1,p2,p3,p4,p5,p6,p7,p8|
+          delta = p5.read_array_of_double(@neq) 
+          @res.call(p1.read_double,p2.read_array_of_double(@neq),p3.read_array_of_double(@neq),delta)
+          p5.write_array_of_double(delta)
+       end
+
+#
+#  jacobian proc called from the Fortran. Let's pass it onto the user's jacboian procedure
+#  in a easier to use form
+#
+       @jacproc = Proc.new do |p1,p2,p3,p4,p5,p6,p7|
+         all = p4.read_array_of_double(@neq*@neq)
+         jacm = Array.new
+         for i in 0..(@neq-1) do
+           arow = Array.new
+           for j in 0..(@neq-1) do
+              arow << all[j*@neq+i]   # Fortran stores in column major, though references in row major     
+           end
+           jacm << arow
+         end
+
+         @jac.call(p1.read_double,p2.read_array_of_double(@neq),p3.read_array_of_double(@neq),jacm,p5.read_double)
+         
+         p4.write_array_of_double(jacm.transpose.flatten)  # Fortran stores in column major, though references in row major 
+       end
+
+
+
+
+    end
+#
+#  solve the initial value problem
+#  this is only required if the Y's and Y'primes are not
+#  already consistent
+#
+#  y or yprime will be modified
+#
+#  init=
+#  * 1 compute derivatives and algebraics from states
+#  * 2 compute algebraics and states from derivatives
+#
+#  ialgs = an array indicating which Y's are algebraics
+#          0 means it is a state (aka has derivative in the equations) 
+#          1 means it is an algebraic
+#    
+    def solveForInitialValues(time,y,yprime,ialgs=[0]*@neqs,init=1)
+
+       ptime = FFI::MemoryPointer.new(:double)
+       ptime.write_double(time)
+       ptout  = FFI::MemoryPointer.new(:double)
+       ptout.write_double(time+1)
+       pidid  = FFI::MemoryPointer.new(:int)
+       @prtol.write_double(@rtol)
+       @patol.write_double(@atol)
+       @y=y
+       @yprime=yprime
+       @py.write_array_of_double(@y)
+       @pyprime.write_array_of_double(@yprime)
+       
+       if (init==1) then
+          @info[10]=1
+          for i in 0..(@neq-1) do
+             @iwork[40+i] = (ialgs[i]==1 ? -1 : 1)     
+          end
+          @info[13]=1
+          @piwork.write_array_of_int(@iwork)
+          @pinfo.write_array_of_int(@info)
+          ddaspk_(@resproc,@pneq,ptime,@py,@pyprime,ptout,@pinfo,@prtol,@patol,pidid,@pwork,@plwr,@piwork,@plwi,nil,nil,@jacproc,nil)
+          @y.replace @py.read_array_of_double(@neq)
+          @yprime.replace @pyprime.read_array_of_double(@neq)
+          idid = pidid.read_int
+       elsif (init==2) then
+          @info[10]=2
+          for i in 0..(@neq-1) do
+             @iwork[40+i] = (ialgs[i]==1 ? -1 : 1)     
+          end
+          @info[13]=1
+          @piwork.write_array_of_int(@iwork)
+          @pinfo.write_array_of_int(@info)
+          ddaspk_(@resproc,@pneq,ptime,@py,@pyprime,ptout,@pinfo,@prtol,@patol,pidid,@pwork,@plwr,@piwork,@plwi,nil,nil,@jacproc,nil)
+          @y.replace @py.read_array_of_double(@neq)
+          @yprime.replace @pyprime.read_array_of_double(@neq)
+          idid = pidid.read_int
+       end
+       @info[13]=0
+       @info[10]=0
+       @info[0]=0 
+       idid
+    
+    end
+
+    def solve (time, tout)
+
+       @prtol.write_double(@rtol)
+       @patol.write_double(@atol)
+
+#
+#  user supply an explicit Jacobian?
+#
+       if (@jac) then
+         @info[4]=1  
+       else
+         @info[4]=0  
+       end
+#
+#  maximum time step option
+#
+       if (@maxstep!=0) then
+          @info[6]=1
+          @work[1]=@maxstep
+       else
+          @info[6]=0
+          @work[1]=@maxstep
+       end 
+
+#
+#  starting time
+#
+       ptime = FFI::MemoryPointer.new(:double)
+       ptime.write_double(time)
+
+#
+#  ending time
+#
+       ptout  = FFI::MemoryPointer.new(:double)
+       ptout.write_double(tout)
+       
+       idid=1
+       pidid  = FFI::MemoryPointer.new(:int)
+       pidid.write_int(idid)
+       
+       @pwork.write_array_of_double(@work)
+       @piwork.write_array_of_int(@iwork)
+       @pinfo.write_array_of_int(@info)
+
+      
+       while (idid==1) do
+          ddaspk_(@resproc,@pneq,ptime,@py,@pyprime,ptout,@pinfo,@prtol,@patol,pidid,@pwork,@plwr,@piwork,@plwi,nil,nil,@jacproc,nil)
+          idid = pidid.read_int
+#
+#  report intermediate values ?
+#
+          if ((idid==1)&&(@inter)) then
+             @inter.call(ptime.read_double,@py.read_array_of_double(@neq),@pyprime.read_array_of_double(@neq))
+          end
+
+       end
+
+       @work =@pwork.read_array_of_double(@lwr) # save the working ram
+       @iwork=@piwork.read_array_of_int(@lwi) 
+       @info[0]=1 
+       [ptime.read_double,@py.read_array_of_double(@neq),@pyprime.read_array_of_double(@neq),idid]
+
+    end
+
+    def reset
+       @info[0]=0
+       @py.write_array_of_double(@y)
+       @pyprime.write_array_of_double(@yprime)
+    end
+
+
+ end
+
+end

data/lib/test.rb

@@ -0,0 +1,131 @@
+# Copyright (c) 2009 Eric Todd Meyers
+#
+# 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.
+#
+#
+# More information, source code and gems @ http://rubyforge.org/projects/rb-daspk/
+#
+#
+
+require 'rubygems'
+require 'rb-daspk'
+include DASPK
+
+y      = [1.0,0.5]
+yprime = [0.0,0.0]
+
+#
+#  in case the user wants to see details during the integration. in this case were just dumping values
+#  not required
+#
+inter = Proc.new do |time,y,yprime|
+    print "time = #{time}   y0=#{y[0]}  y1=#{y[1]}\n"
+end
+
+
+#
+#  let's solve and easy one
+#
+#     dy1/dy = y1
+#     dy2/dt = 2*y2
+#
+#  we all know the answer is (for the starting y's above)
+#     y1 = e**t
+#     y2 = e**(2t+ln(0.5))
+#
+#  at 2 seconds we should get y1 = 7.389056098930649, y2 = 27.29907501657209
+#
+#
+
+#
+#  explicit modified jacobian
+#  not required, but used if passed to solver
+#
+jac = Proc.new do |time,y,yprime,pd,cj|
+   pd[0][0] = 1.0 - cj   # first equation with respect to first var
+   pd[0][1] = 0.0        # first equation with respect to second var
+   pd[1][0] = 0.0        # second equation with respect to first var
+   pd[1][1] = 2.0 - cj   # second equation with respect to second var
+end
+
+s=Solver.new(2,y,yprime,inter, jac) do |time,yy,yyprime,delta| 
+#s=Solver.new(2,y,yprime,inter) do |time,yy,yyprime,delta|
+             delta[0]  =     yy[0] - yyprime[0] 
+             delta[1]  = 2.0*yy[1] - yyprime[1] 
+end
+
+
+#
+#  solve the initial value problem
+#  this is only required if the Y's and Y'primes are not
+#  already consistent
+#
+#  y and yprime will be modified
+#
+#
+#
+#
+#
+#
+ans = s.solveForInitialValues(0,y,yprime,[0,0],1)
+print " y0=#{y[0]}  y1=#{y[1]}\n"
+print " yp0=#{yprime[0]}  yp1=#{yprime[1]}\n"
+print "idid = #{ans}\n"
+
+#
+# integrate to 1 second
+#
+ans = s.solve(0.0,1.0) 
+
+
+#print final values
+time = ans[0]
+ya = ans[1]
+ypa = ans[2]
+print "time = #{time}   y0=#{ya[0]}  y1=#{ya[1]}\n"
+print "time = #{time}   yp0=#{ypa[0]}  yp1=#{ypa[1]}\n"
+
+#
+# lets keep going. should start at the last time we left off regardless of the sart time
+# integrate to 2 seconds
+#
+ans = s.solve(0.0,2.0) 
+#print final values
+time = ans[0]
+ya = ans[1]
+ypa = ans[2]
+print "time = #{time}   y0=#{ya[0]}  y1=#{ya[1]}\n"
+print "time = #{time}   yp0=#{ypa[0]}  yp1=#{ypa[1]}\n"
+
+#
+# reset integration. should go back to tzero
+# integrate to 2 seconds
+#
+s.reset
+
+ans = s.solve(0.0,2.0) 
+#print final values
+time = ans[0]
+ypa = ans[2]
+ya = ans[1]
+print "time = #{time}   y0=#{ya[0]}  y1=#{ya[1]}\n"
+print "time = #{time}   yp0=#{ypa[0]}  yp1=#{ypa[1]}\n"

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: rb-daspk
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: x86-darwin-10
+authors: 
+- Eric Meyers
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-28 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ffi
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.5.3
+    version: 
+description: Allows users to solve differential algebraic equations in Ruby, using Ruby constructs. Interfaces with the DASPK Fortran library. DASPK solves DAE's of the form G(t,y,y',p) = 0
+email: etm@ericmeyers.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/libdaspk.dylib
+- lib/rb-daspk.rb
+- lib/test.rb
+has_rdoc: false
+homepage: 
+post_install_message: 
+rdoc_options: 
+- --inline-source
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: rb-daspk
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: DASPK Ruby Interface. Allows users to solve differential algebraic equations in Ruby, using Ruby constructs. Interfaces with the DASPK Fortran library. DASPK solves DAE's of the form G(t,y,y',p) = 0
+test_files: []
+