rb-daspk 0.0.5-x86-mswin32-60

data/examples/springmass.rb

@@ -0,0 +1,130 @@
+# 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
+
+#
+#  classic spring mass problem
+#
+#     d2x/dt + 2*l*w0*dxdt + w0*w0*x = 0
+#
+#     let v = dx/dt, then
+#
+#  1. dxdt - v = 0  
+#  2. dvdt + 2*l*w0*v + w0*w0*x = 0
+#
+#
+#  let's start with x at 1, dxdt at 0 (v=0)
+#  we'll ask DASPK for the state derivatives
+#
+y     = [1.0,0.0]
+yprime= [0.0,-1.0] # these are gusses in this case. we will call solveForInitialValues to get them
+
+
+w0 = 1.0
+l  = 0.0 # undamped
+
+#
+#  in case we want to see details during the integration. in this case were just dumping values
+#  not required (can pass nil to Solver.new if you want)
+#
+inter = Proc.new do |time,y,yprime|
+   print " time = #{time}  x = #{y[0]}\n"
+end
+
+jac = Proc.new do |time,y,yprime,jacm,cj|
+
+   jacm[0][0] = cj
+   jacm[0][1] = -1.0
+   jacm[1][0] = w0**2.0
+   jacm[1][1] = (2*l*w0 + cj)
+
+end
+
+s=Solver.new(2,y,yprime,inter,jac) do |time,y,yprime,delta|
+#s=Solver.new(2,y,yprime,inter) do |time,y,yprime,delta|
+             delta[0]  = yprime[0] - y[1] 
+             delta[1]  = yprime[1] + 2.0*l*w0*y[1] + w0*w0*y[0] 
+end
+
+
+#
+#  solve the initial value problem
+#  note, this isnt required if the y and yprimes are already consistent
+# 
+#  return code from solveFoeInitialValues
+#    4 success (see DDASPK for all possible values)
+#
+idid = s.solveForInitialValues(0,y,yprime,[0,0])
+print " ----------------------------------------\n"
+print " initial conditions\n"
+print " x            = #{y[0]}\n"
+print " vel          = #{y[1]}\n"
+print " accelaration = #{yprime[1]}\n"
+print " ----------------------------------------\n"
+
+#
+# integrate to PI seconds
+#
+#
+ans = s.solve(0.0,Math::PI) 
+#
+# answer is an array of arrays
+# ans[0] = end time
+# ans[1] = end y array
+# ans[2] = end yprime array
+# ans[3] = DASPK return code (see DDASPK.F for meaning)
+#
+print " ----------------------------------------\n"
+print " final conditions\n"
+print " time         = #{ans[0]}\n"
+print " x            = #{ans[1][0]}\n"
+print " vel          = #{ans[1][1]}\n"
+print " accelaration = #{ans[2][1]}\n"
+print " ----------------------------------------\n"
+
+#
+# continue to integrate to 2PI seconds
+#
+#
+ans = s.solve(0.0,2*Math::PI) 
+#
+# answer is an array of arrays
+# ans[0] = end time
+# ans[1] = end y array
+# ans[2] = end yprime array
+# ans[3] = DASPK return code (see DDASPK.F for meaning)
+#
+print " ----------------------------------------\n"
+print " final conditions\n"
+print " time         = #{ans[0]}\n"
+print " x            = #{ans[1][0]}\n"
+print " vel          = #{ans[1][1]}\n"
+print " accelaration = #{ans[2][1]}\n"
+print " ----------------------------------------\n"

data/lib/rb-daspk.rb

@@ -0,0 +1,317 @@
+# 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/
+#
+#:main:DASPK::Solver
+#
+
+
+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 DASPKLIB
+  extend FFI::Library
+  ffi_lib File.dirname(__FILE__) +  '/daspk.dll'
+  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
+  attach_function 'D1MACH', [:pointer],:double
+end
+
+module DASPK
+#
+#  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 DASPKLIB
+    attr_accessor :rtol,:atol,:inter,: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      = 500
+       @lwi      = 500
+       @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    = [0]*neq
+       @res      = res
+       @inter    = inter
+       @rtol     = 0.000001
+       @atol     = 0.000001
+       @jac      = jac
+       @maxstep  = 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
+#
+#  the contents of 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,init=1,mxnit=5,mxnj=6,mxnh=5,lsoff=0,stptol=0,epinit=0.01)
+
+       @mxnit     = mxnit
+       @mxnj      = mxnj
+       @mxnh      = mxnh
+       @lsoff     = lsoff
+       pidum      = FFI::MemoryPointer.new(:int)
+       @stptol    = (stptol==0 ? D1MACH(pidum)**(2.0/3.0) : stptol)
+       @epinit    = epinit
+       @info[16]  = 1
+       @iwork[31] = @mxnit
+       @iwork[32] = @mxnj
+       @iwork[33] = @mxnh
+       @iwork[34] = @lsoff
+       @work[13]  = @stptol
+       @work[14]  = @epinit
+
+       ptime      = FFI::MemoryPointer.new(:double)
+       ptout      = FFI::MemoryPointer.new(:double)
+       pidid      = FFI::MemoryPointer.new(:int)
+       @y         = y
+       @yprime    = yprime
+
+       ptime.write_double(time)
+       ptout.write_double(time+1)
+       @py.write_array_of_double(@y)
+       @pyprime.write_array_of_double(@yprime)
+       @prtol.write_double(@rtol)
+       @patol.write_double(@atol)
+       
+       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)
+          @pwork.write_array_of_double(@work)
+          @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)
+          @pwork.write_array_of_double(@work)
+          @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
+       @info[16] = 0
+       idid
+    
+    end
+
+    def solve (time, tout)
+#
+#  solver options
+#
+
+       @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

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: rb-daspk
+version: !ruby/object:Gem::Version 
+  version: 0.0.5
+platform: x86-mswin32-60
+authors: 
+- Eric Meyers
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-05 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/daspk.dll
+- lib/rb-daspk.rb
+- examples/springmass.rb
+has_rdoc: true
+homepage: http://rb-daspk.rubyforge.org
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- -S
+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.5
+signing_key: 
+specification_version: 3
+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: []
+