ode 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 268ad106e9a7617020dd7ee6d9cf540b694d2cfe
+  data.tar.gz: 5e8c6e7fc50b16cf2eee39142e8f72d5cc6998d2
+SHA512:
+  metadata.gz: 713a2c92a16b3e9200eab1ed5d2c19f16cd4d0983200ac9a2d754aacca88b2af05315d6277e3e7a0245108b21b809755b6e7fb12d45d5cd2f117fe9263ded02d
+  data.tar.gz: 6e9a85ea3afbd29063e43e25e01d3ac3d7f6becda3ee6ad0e5643d862f37151680947fc79042e90f09eb95ed4c28e0202cf4b66a2ec3fab90f0692e435481bdb

data/.gitignore

@@ -0,0 +1,37 @@
+*.gem
+*.rbc
+*.o
+*~
+*.so
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in oderb.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,17 @@
+PATH
+  remote: .
+  specs:
+    ode (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (10.3.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.5)
+  ode!
+  rake

data/MIT-License.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Naoki Nishida
+
+MIT License
+
+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.

data/README.md

@@ -0,0 +1,32 @@
+# Ode
+
+[![Gem Version](https://badge.fury.io/rb/ode.svg)](http://badge.fury.io/rb/ode)
+
+An ODE solver package for Ruby users.
+Ode is a the wrapper for [ODEPACK](https://computation.llnl.gov/casc/odepack/) and may perform as well as scipy.integrate.odeint and other wrappers.
+
+## Installation
+```
+gem install ode
+```
+
+## Examples
+```
+require 'ode'
+
+f = Proc.new{|t, y, fargs|
+  p, r, b = fargs[:p], fargs[:r], fargs[:b]
+    [ -p*y[0] + p*y[1],
+      -y[0]*y[2] + r*y[0] - y[1],
+      y[0]*y[1] - b*y[2]
+    ]
+}
+
+solver = Ode::Solver.new(f).init(0, [0, 0, 0]).f_args({p: 10, r: 28, b: 8/3}).
+solver.integrate(3.0) #integrate f from t=0 to t=3.0
+```
+
+## License
+
+All files under ext/ode/odepack are from scipy.integrate (originally from ODEPACK), and distributed under [SciPy License](https://github.com/domitry/ode/blob/master/SciPy-License.txt).  
+All the other files are distributed under [the MIT License](https://github.com/domitry/ode/blob/master/MIT-License.txt).

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler'
+require 'rake/extensiontask'
+
+Bundler::GemHelper.install_tasks
+Bundler.setup(:default, :development)
+
+Rake::ExtensionTask.new do |ext|
+  ext.name = 'ode'
+  ext.ext_dir = 'ext/ode'
+  ext.lib_dir = 'lib'
+  ext.source_pattern = "**/*.{f, c, h}"
+end

data/SciPy-License.txt

@@ -0,0 +1,30 @@
+Copyright (c) 2001, 2002 Enthought, Inc.
+All rights reserved.
+
+Copyright (c) 2003-2012 SciPy Developers.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  a. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+  b. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+  c. Neither the name of Enthought nor the names of the SciPy Developers
+     may be used to endorse or promote products derived from this software
+     without specific prior written permission.
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+THE POSSIBILITY OF SUCH DAMAGE.

data/ext/ode/extconf.rb

@@ -0,0 +1,25 @@
+require 'mkmf'
+
+$DEBUG = true
+$libs += " -llapack -lcblas -latlas"
+
+$INSTALLFILES = [['odepack.h', '$(archdir)'], ['ode.so', '$(archdir)']]
+
+path = File.expand_path("../odepack", __FILE__)
+odepack_c = Dir::entries(path).select {|str| str =~ /(.+)\.f/}.map{|str| "odepack/"+str}
+odepack_obj = odepack_c.map{|str| str.gsub(".f", ".o")}
+other_c = %w{ode.c}
+other_obj = other_c.map{|str| str.gsub(".c", ".o")}
+
+$objs = odepack_obj + other_obj
+$srcs = odepack_c + other_c
+
+create_makefile("ode")
+
+Dir.mkdir("odepack") unless Dir.exists?("odepack")
+
+if $makefile_created
+  text = File.read("Makefile")
+  text.gsub!(".mm", ".f")
+  File.write("Makefile", text)
+end

data/ext/ode/ode.c

@@ -0,0 +1,124 @@
+#include "odepack.h"
+#include <stdlib.h>
+#include <ruby.h>
+#include <stdio.h>
+
+static int number_of_params;
+static VALUE func_proc, jac_proc, f_args;
+
+#define RESTORE_NEQ(neq) number_of_params=neq;
+#define RESTORE_FUNC(func) func_proc=func;
+#define RESTORE_JAC(func) jac_proc=func;
+#define RESTORE_FARGS(args) f_args=args;
+#define max(v1, v2) (v1 < v2 ? v2 : v1)
+#define min(v1, v2) (v1 < v2 ? v1 : v2)
+
+int ode_jacobian_function(int *n, double *t, double *y, int *ml, int *mu, double *pd, int *nrowpd){
+  return -1;
+}
+
+void ode_function(int *n, double *t, double *y, double *ydot){
+  VALUE y_arr = rb_ary_new2(number_of_params), ret;
+  int i;
+
+  for(i=0; i<number_of_params; i++)
+    rb_ary_store(y_arr, i, DBL2NUM(y[i]));
+  
+  ret = rb_funcall(func_proc, rb_intern("call"), 3, DBL2NUM(*t), y_arr, f_args);
+
+  for(i=0; i<number_of_params; i++){
+    VALUE num = rb_ary_entry(ret, i);
+    ydot[i] = NUM2DBL(num);
+  }
+}
+
+VALUE excute_lsoda(VALUE self, VALUE t_out, VALUE func, VALUE jac, VALUE init_t, VALUE init_y, VALUE fargs, VALUE opts){
+  int itol; double rtol, atol;
+  int *iwork; double *rwork;
+  int lrw, liw;
+  int neq = RARRAY_LEN(init_y);
+
+  double *y = (double *)ALLOC_N(double, neq);
+  double t = NUM2DBL(init_t);
+  double tout = NUM2DBL(t_out);
+
+  int itask = 1;  // run solver untill t == tout
+  int istate = 1; // this is the first call of the problem
+  int iopt = 0;   // no optional inputs
+
+  int jt = 2;     // jacobian type indicator. 1: user provides full jacobian. 2: interanally generated jacobian.
+  VALUE ret_arr = rb_ary_new2(neq);
+  double h0 = 0, hmax =0, hmin = 0;
+  int ixpr=0, max_step=0, max_hnil=0, max_ordn=12, max_ords=5;
+  int i;
+
+  RESTORE_NEQ(neq)
+  RESTORE_FUNC(func)
+  RESTORE_FARGS(fargs)
+
+  for(i=0; i<neq; i++){
+    y[i] = NUM2DBL(rb_ary_entry(init_y, i));
+  }
+
+  // parse options (TODO: accept array)
+  itol = NUM2INT(rb_hash_lookup(opts, ID2SYM(rb_intern("itol"))));
+
+  rtol = NUM2DBL(rb_hash_aref(opts, ID2SYM(rb_intern("rtol"))));
+  atol = NUM2DBL(rb_hash_aref(opts, ID2SYM(rb_intern("atol"))));
+
+  // decide lrw, liw
+  liw = 20 + neq;
+  iwork = (int *)ALLOC_N(int, liw);
+
+  if(jac != Qnil){
+    jt = 1;
+    RESTORE_JAC(jac);
+    lrw = max(20+16*neq, 22+9*neq+neq*neq);
+  }
+  else{
+    int ml=0, mu=0; VALUE val;
+    if(val = rb_hash_aref(opts, ID2SYM(rb_intern("ml"))) != Qnil)ml = NUM2INT(val);
+    if(val = rb_hash_aref(opts, ID2SYM(rb_intern("mu"))) != Qnil)mu = NUM2INT(val);
+
+    iwork[0] = mu;
+    iwork[1] = ml;
+    lrw = max(20+16*neq, 22+10*neq+(2*ml+mu)*neq);
+  }
+
+  rwork = (double *)ALLOC_N(double, lrw);
+  rwork[4] = h0;
+  rwork[5] = hmax;
+  rwork[6] = hmin;
+
+  iwork[4] = ixpr;
+  iwork[5] = max_step;
+  iwork[6] = max_hnil;
+  iwork[7] = max_ordn;
+  iwork[8] = max_ords;
+
+  // run lsoda
+  lsoda_(ode_function, &neq, y, &t, &tout, &itol, &rtol, &atol, &itask, &istate, &iopt, rwork, &lrw, iwork, &liw, ode_jacobian_function, &jt);
+
+  // check error
+  if(istate<0){
+    rb_raise(rb_eTypeError, "Something went wrong.");
+  }
+
+  for(i=0; i<neq; i++){
+    VALUE num = DBL2NUM(y[i]);
+    rb_ary_store(ret_arr, i, num);
+  }
+
+  xfree(y);
+  xfree(iwork);
+  xfree(rwork);
+  return ret_arr;
+}
+
+
+void Init_ode(){
+  VALUE ode = rb_define_module("Ode");
+  VALUE methods = rb_define_module_under(ode, "Methods");
+
+  rb_define_singleton_method(methods, "lsoda", excute_lsoda, 7);
+}

data/ext/ode/odepack.h

@@ -0,0 +1,6 @@
+void lsoda_(void (*f)(int*, double*, double*, double*), int *neq, double *y, double *t, double *tout, int *itol, double *rtol, double *atol, int *itask, int *istate, int *iopt, double *rwork, int *lrw, int *iwork, int *liw, int (*jac)(int*, double*, double*, int*, int*,  double*, int*), int *jt);
+
+  /*int itol = 2; // indicator for error control
+  double rtol = 1e-4; // relative error tolerance parameter (scalar or array)
+  double atol[3] = {1e-6, 1e-10, 1e-6}; // absolute error tolerance parameter  (scalar or array)
+  */

data/ext/ode/odepack/blkdta000.f

@@ -0,0 +1,26 @@
+      block data
+c-----------------------------------------------------------------------
+c this data subprogram loads variables into the internal common
+c blocks used by the odepack solvers.  the variables are
+c defined as follows..
+c   illin  = counter for the number of consecutive times the package
+c            was called with illegal input.  the run is stopped when
+c            illin reaches 5.
+c   ntrep  = counter for the number of consecutive times the package
+c            was called with istate = 1 and tout = t.  the run is
+c            stopped when ntrep reaches 5.
+c   mesflg = flag to control printing of error messages.  1 means print,
+c            0 means no printing.
+c   lunit  = default value of logical unit number for printing of error
+c            messages.
+c-----------------------------------------------------------------------
+      integer illin, iduma, ntrep, idumb, iowns, icomm, mesflg, lunit
+      double precision rowns, rcomm
+      common /ls0001/ rowns(209), rcomm(9),
+     1   illin, iduma(10), ntrep, idumb(2), iowns(6), icomm(19)
+      common /eh0001/ mesflg, lunit
+      data illin/0/, ntrep/0/
+      data mesflg/1/, lunit/6/
+c
+c----------------------- end of block data -----------------------------
+      end

data/ext/ode/odepack/bnorm.f

@@ -0,0 +1,30 @@
+      double precision function bnorm (n, a, nra, ml, mu, w)
+clll. optimize
+c-----------------------------------------------------------------------
+c this function computes the norm of a banded n by n matrix,
+c stored in the array a, that is consistent with the weighted max-norm
+c on vectors, with weights stored in the array w.
+c ml and mu are the lower and upper half-bandwidths of the matrix.
+c nra is the first dimension of the a array, nra .ge. ml+mu+1.
+c in terms of the matrix elements a(i,j), the norm is given by..
+c   bnorm = max(i=1,...,n) ( w(i) * sum(j=1,...,n) abs(a(i,j))/w(j) )
+c-----------------------------------------------------------------------
+      integer n, nra, ml, mu
+      integer i, i1, jlo, jhi, j
+      double precision a, w
+      double precision an, sum
+      dimension a(nra,n), w(n)
+      an = 0.0d0
+      do 20 i = 1,n
+        sum = 0.0d0
+        i1 = i + mu + 1
+        jlo = max0(i-ml,1)
+        jhi = min0(i+mu,n)
+        do 10 j = jlo,jhi
+ 10       sum = sum + dabs(a(i1-j,j))/w(j)
+        an = dmax1(an,sum*w(i))
+ 20     continue
+      bnorm = an
+      return
+c----------------------- end of function bnorm -------------------------
+      end

data/ext/ode/odepack/cfode.f

@@ -0,0 +1,112 @@
+      subroutine cfode (meth, elco, tesco)
+clll. optimize
+      integer meth
+      integer i, ib, nq, nqm1, nqp1
+      double precision elco, tesco
+      double precision agamq, fnq, fnqm1, pc, pint, ragq,
+     1   rqfac, rq1fac, tsign, xpin
+      dimension elco(13,12), tesco(3,12)
+c-----------------------------------------------------------------------
+c cfode is called by the integrator routine to set coefficients
+c needed there.  the coefficients for the current method, as
+c given by the value of meth, are set for all orders and saved.
+c the maximum order assumed here is 12 if meth = 1 and 5 if meth = 2.
+c (a smaller value of the maximum order is also allowed.)
+c cfode is called once at the beginning of the problem,
+c and is not called again unless and until meth is changed.
+c
+c the elco array contains the basic method coefficients.
+c the coefficients el(i), 1 .le. i .le. nq+1, for the method of
+c order nq are stored in elco(i,nq).  they are given by a genetrating
+c polynomial, i.e.,
+c     l(x) = el(1) + el(2)*x + ... + el(nq+1)*x**nq.
+c for the implicit adams methods, l(x) is given by
+c     dl/dx = (x+1)*(x+2)*...*(x+nq-1)/factorial(nq-1),    l(-1) = 0.
+c for the bdf methods, l(x) is given by
+c     l(x) = (x+1)*(x+2)* ... *(x+nq)/k,
+c where         k = factorial(nq)*(1 + 1/2 + ... + 1/nq).
+c
+c the tesco array contains test constants used for the
+c local error test and the selection of step size and/or order.
+c at order nq, tesco(k,nq) is used for the selection of step
+c size at order nq - 1 if k = 1, at order nq if k = 2, and at order
+c nq + 1 if k = 3.
+c-----------------------------------------------------------------------
+      dimension pc(12)
+c
+      go to (100, 200), meth
+c
+ 100  elco(1,1) = 1.0d0
+      elco(2,1) = 1.0d0
+      tesco(1,1) = 0.0d0
+      tesco(2,1) = 2.0d0
+      tesco(1,2) = 1.0d0
+      tesco(3,12) = 0.0d0
+      pc(1) = 1.0d0
+      rqfac = 1.0d0
+      do 140 nq = 2,12
+c-----------------------------------------------------------------------
+c the pc array will contain the coefficients of the polynomial
+c     p(x) = (x+1)*(x+2)*...*(x+nq-1).
+c initially, p(x) = 1.
+c-----------------------------------------------------------------------
+        rq1fac = rqfac
+        rqfac = rqfac/dfloat(nq)
+        nqm1 = nq - 1
+        fnqm1 = dfloat(nqm1)
+        nqp1 = nq + 1
+c form coefficients of p(x)*(x+nq-1). ----------------------------------
+        pc(nq) = 0.0d0
+        do 110 ib = 1,nqm1
+          i = nqp1 - ib
+ 110      pc(i) = pc(i-1) + fnqm1*pc(i)
+        pc(1) = fnqm1*pc(1)
+c compute integral, -1 to 0, of p(x) and x*p(x). -----------------------
+        pint = pc(1)
+        xpin = pc(1)/2.0d0
+        tsign = 1.0d0
+        do 120 i = 2,nq
+          tsign = -tsign
+          pint = pint + tsign*pc(i)/dfloat(i)
+ 120      xpin = xpin + tsign*pc(i)/dfloat(i+1)
+c store coefficients in elco and tesco. --------------------------------
+        elco(1,nq) = pint*rq1fac
+        elco(2,nq) = 1.0d0
+        do 130 i = 2,nq
+ 130      elco(i+1,nq) = rq1fac*pc(i)/dfloat(i)
+        agamq = rqfac*xpin
+        ragq = 1.0d0/agamq
+        tesco(2,nq) = ragq
+        if (nq .lt. 12) tesco(1,nqp1) = ragq*rqfac/dfloat(nqp1)
+        tesco(3,nqm1) = ragq
+ 140    continue
+      return
+c
+ 200  pc(1) = 1.0d0
+      rq1fac = 1.0d0
+      do 230 nq = 1,5
+c-----------------------------------------------------------------------
+c the pc array will contain the coefficients of the polynomial
+c     p(x) = (x+1)*(x+2)*...*(x+nq).
+c initially, p(x) = 1.
+c-----------------------------------------------------------------------
+        fnq = dfloat(nq)
+        nqp1 = nq + 1
+c form coefficients of p(x)*(x+nq). ------------------------------------
+        pc(nqp1) = 0.0d0
+        do 210 ib = 1,nq
+          i = nq + 2 - ib
+ 210      pc(i) = pc(i-1) + fnq*pc(i)
+        pc(1) = fnq*pc(1)
+c store coefficients in elco and tesco. --------------------------------
+        do 220 i = 1,nqp1
+ 220      elco(i,nq) = pc(i)/pc(2)
+        elco(2,nq) = 1.0d0
+        tesco(1,nq) = rq1fac
+        tesco(2,nq) = dfloat(nqp1)/elco(1,nq)
+        tesco(3,nq) = dfloat(nq+2)/elco(1,nq)
+        rq1fac = rq1fac/fnq
+ 230    continue
+      return
+c----------------------- end of subroutine cfode -----------------------
+      end