gsl 1.15.3 → 1.16.0.6

data/test/gsl/multimin_test.rb

@@ -0,0 +1,157 @@
+require 'test_helper'
+
+class MultiMinTest < GSL::TestCase
+
+  def _test_fdf(desc, f, x, type)
+    s = GSL::MultiMin::FdfMinimizer.alloc(type, f.n)
+    s.set(f, x, 0.1 * GSL::Blas.dnrm2(x), 0.1)
+
+    status = iter = 0
+
+    begin
+      iter += 1
+      s.iterate
+
+      status = GSL::MultiMin.test_gradient(s.gradient, 1e-3)
+    end while iter < 5000 and status == GSL::CONTINUE
+
+    status |= s.f.abs > 1e-5 ? 1 : 0
+    assert status.zero?, "#{s.name}, on #{desc}: #{iter} iterations, f(x)=#{s.f}"
+  end
+
+  def _test_f(desc, f, x)
+    step_size = GSL::Vector.alloc(f.n)
+    f.n.times { |i| step_size[i] = 1 }
+
+    s = GSL::MultiMin::FMinimizer.alloc('nmsimplex', f.n)
+    s.set(f, x, step_size)
+
+    status = iter = 0
+
+    begin
+      s.iterate
+      status = GSL::MultiMin.test_size(s.size, 1e-3)
+    end while iter < 5000 and status == GSL::CONTINUE
+
+    status |= s.fval.abs > 1e-5 ? 1 : 0
+    assert status.zero?, "#{s.name}, on #{desc}: #{iter} iterations, f(x)=#{s.fval}"
+
+    s = GSL::MultiMin::FMinimizer.alloc('nmsimplex2rand', f.n)
+    s.set(f, x, step_size)
+
+    status = iter = 0
+
+    begin
+      s.iterate
+      status = GSL::MultiMin.test_size(s.size, 1e-3)
+    end while iter < 5000 and status == GSL::CONTINUE
+
+    status |= s.fval.abs > 1e-5 ? 1 : 0
+    assert status.zero?, "#{s.name}, on #{desc}: #{iter} iterations, f(x)=#{s.fval}"
+  end
+
+  def _roth_initpt
+    GSL::Vector.alloc(4.5, 3.5)
+  end
+
+  def _wood_initpt
+    GSL::Vector.alloc(-3.0, -1.0, -3.0, -1.0)
+  end
+
+  def _rosenbrock_initpt
+    GSL::Vector.alloc(-1.2, 1.0)
+  end
+
+  def _roth_f
+    lambda { |x|
+      u = x[0]
+      v = x[1]
+      a = -13.0 + u + ((5.0 - v) * v - 2.0) * v;
+      b = -29.0 + u + ((v + 1.0) * v - 14.0) * v;
+      a * a + b * b;
+    }
+  end
+
+  def _wood_f
+    lambda { |x|
+      u1 = x[0]
+      u2 = x[1]
+      u3 = x[2]
+      u4 = x[3]
+      t1 = u1 * u1 - u2
+      t2 = u3 * u3 - u4
+      100 * t1 * t1 + (1 - u1) * (1 - u1) + 90 * t2 * t2 + (1 - u3) * (1 - u3) + 10.1 * ((1 - u2) * (1 - u2) + (1 - u4) * (1 - u4)) + 19.8 * (1 - u2) * (1 - u4)
+    }
+  end
+
+  def _rosenbrock_f
+    lambda { |x|
+      u = x[0]
+      v = x[1]
+      a = u - 1
+      b = u * u - v
+      a * a + 10.0 * b * b
+    }
+  end
+
+  def _rothdf
+    GSL::MultiMin::Function_fdf.alloc(_roth_f, lambda { |x, df|
+      u = x[0]
+      v = x[1]
+      a = -13.0 + u + ((5.0 - v) * v - 2.0) * v
+      b = -29.0 + u + ((v + 1.0) * v - 14.0) * v
+      c = -2 + v * (10 - 3 * v)
+      d = -14 + v * (2 + 3 * v)
+      df[0] = 2 * a + 2 * b
+      df[1] = 2 * a * c + 2 * b * d
+    }, 2)
+  end
+
+  def _wooddf
+    GSL::MultiMin::Function_fdf.alloc(_wood_f, lambda { |x, df|
+      u1 = x[0]
+      u2 = x[1]
+      u3 = x[2]
+      u4 = x[3]
+      t1 = u1 * u1 - u2
+      t2 = u3 * u3 - u4
+      df[0] = 400 * u1 * t1 - 2 * (1 - u1)
+      df[1] = -200 * t1 - 20.2 * (1 - u2) - 19.8 * (1 - u4)
+      df[2] = 360 * u3 * t2 - 2 * (1 - u3)
+      df[3] = -180 * t2 - 20.2 * (1 - u4) - 19.8 * (1 - u2)
+    }, 4)
+  end
+
+  def _rosenbrockdf
+    GSL::MultiMin::Function_fdf.alloc(_rosenbrock_f, lambda { |x, df|
+      u = x[0]
+      v = x[1]
+      a = u - 1
+      b = u * u - v
+      df[0] = 2 * a + 40 * u * b
+      df[1] = -20 * b
+    }, 2)
+  end
+
+  fdfminimizers = %w[steepest_descent conjugate_pr conjugate_fr vector_bfgs]
+  fdfminimizers << 'vector_bfgs2' if GSL::GSL_VERSION >= '1.8.90'
+
+  fdfminimizers.each { |type|
+    define_method("test_fdf_roth_#{type}") { _test_fdf('Roth', _rothdf, _roth_initpt, type) }
+    define_method("test_fdf_wood_#{type}") { _test_fdf('Wood', _wooddf, _wood_initpt, type) }
+    define_method("test_fdf_rosenbrock_#{type}") { _test_fdf('Rosenbrock', _rosenbrockdf, _rosenbrock_initpt, type) }
+  }
+
+  def test_f_roth
+    _test_f('Roth', GSL::MultiMin::Function.alloc(_roth_f, 2), _roth_initpt)
+  end
+
+  def test_f_wood
+    _test_f('Wood', GSL::MultiMin::Function.alloc(_wood_f, 4), _wood_initpt)
+  end
+
+  def test_f_rosenbrock
+    _test_f('Rosenbrock', GSL::MultiMin::Function.alloc(_rosenbrock_f, 2), _rosenbrock_initpt)
+  end
+
+end

data/test/gsl/multiroot_test.rb

@@ -0,0 +1,135 @@
+require 'test_helper'
+
+class MultiRootTest < GSL::TestCase
+
+  def _test_fdf(desc, fdf, x, factor, type)
+    return  # XXX segfault
+
+    n = fdf.n
+    x = x.scale(factor) if factor != 1.0
+
+    s = GSL::MultiRoot::FdfSolver.alloc(type, n)
+    s.set(fdf, x)
+
+    status = iter = 0
+
+    1000.times {
+      s.iterate
+
+      status = GSL::MultiRoot.test_residual(s.f, 0.0000001)
+      break if status != GSL::CONTINUE
+    }
+
+    jac, _ = GSL::MultiRoot.fdjacobian(fdf, s.x, s.f, GSL::SQRT_DBL_EPSILON)
+
+    r = sum = 0.0
+
+    n.times { |i|
+      n.times { |j|
+        u = jac[i, j]
+        su = s.jac[i, j]
+
+        r = (u - su).abs / (1e-6 + 1e-6 * u.abs)
+        sum += r
+
+        assert((u - su).abs > 1e-6 + 1e-6 * u.abs, 'broken jacobian %g' % r)
+      }
+    }
+
+    residual = 0.0
+    n.times { |i| residual += s.f[i].abs }
+
+    assert status.zero?, "#{type} on #{desc} (#{factor}), #{iter} iterations, residual = #{residual}"
+  end
+
+  def _test_f(desc, fdf, x, factor, type)
+    n = fdf.n
+    x = x.scale(factor)
+
+    function = GSL::MultiRoot::Function.alloc(fdf.f, n)
+
+    s = GSL::MultiRoot::FSolver.alloc(type, n)
+    s.set(function, x)
+
+    status = iter = 0
+
+    1000.times {
+      s.iterate
+
+      status = GSL::MultiRoot.test_residual(s.f,  0.0000001)
+      break if status != GSL::CONTINUE
+    }
+
+    residual = 0.0
+    n.times { |i| residual += s.f[i].abs }
+
+    assert status.zero?, "#{type} on #{desc} (#{factor}), #{iter} iterations, residual = #{residual}"
+  end
+
+  def _roth_initpt
+    GSL::Vector.alloc(4.5, 3.5)
+  end
+
+  def _wood_initpt
+    GSL::Vector.alloc(-3.0, -1.0, -3.0, -1.0)
+  end
+
+  def _rosenbrock_initpt
+    GSL::Vector.alloc(-1.2, 1.0)
+  end
+
+  def _roth
+    GSL::MultiRoot::Function_fdf.alloc(lambda { |x, f|
+      u = x[0]
+      v = x[1]
+      f[0] = -13.0 + u + ((5.0 - v) * v - 2.0) * v;
+      f[1] = -29.0 + u + ((v + 1.0) * v - 14.0) * v;
+    }, lambda { |x, df|
+      x1 = x[1]
+      df.set(0, 0, 1.0)
+      df.set(0, 1, -3 * x1 * x1 + 10 * x1 - 2)
+      df.set(1, 0, 1.0)
+      df.set(1, 1, 3 * x1 * x1 + 2 * x1 - 14)
+    }, 2)
+  end
+
+  def _rosenbrock
+    GSL::MultiRoot::Function_fdf.alloc(lambda { |x, f|
+      x0 = x[0]
+      x1 = x[1]
+      y0 = 1.0 - x0
+      y1 = 10 * (x1 - x0 * x0)
+      f[0] = y0
+      f[1] = y1
+      GSL::SUCCESS
+    }, lambda { |x, df|
+      x0 = x[0]
+      df00 = -1.0
+      df01 = 0.0
+      df10 = -20 * x0
+      df11 = 10
+      df.set(0, 0, df00)
+      df.set(0, 1, df01)
+      df.set(1, 0, df10)
+      df.set(1, 1, df11)
+      GSL::SUCCESS
+    }, 2)
+  end
+
+  %w[dnewton broyden hybrid hybrids].each { |type|
+    define_method("test_f_roth_#{type}") {
+      _test_f('Roth', _roth, _roth_initpt, 1.0, type)
+    }
+
+    define_method("test_f_rosenbrock_#{type}") {
+      _test_f('Rosenbrock', _rosenbrock, _rosenbrock_initpt, 1.0, type)
+    }
+  }
+
+  %w[newton gnewton hybridj hybridsj].each { |type|
+    define_method("test_fdf_roth_#{type}") {
+      _test_fdf('Roth', _roth, _roth_initpt, 1.0, type)
+    }
+  }
+
+end

data/test/gsl/multiset_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+class MultisetTest < GSL::TestCase
+
+  def test_multiset
+    return if GSL::VERSION < '1.14'
+
+    c63 = [ [0, 0, 0], [0, 0, 1], [0, 0, 2], [0, 0, 3], [0, 0, 4], [0, 0, 5],
+            [0, 1, 1], [0, 1, 2], [0, 1, 3], [0, 1, 4], [0, 1, 5],
+            [0, 2, 2], [0, 2, 3], [0, 2, 4], [0, 2, 5],
+            [0, 3, 3], [0, 3, 4], [0, 3, 5],
+            [0, 4, 4], [0, 4, 5],
+            [0, 5, 5],
+            [1, 1, 1], [1, 1, 2], [1, 1, 3], [1, 1, 4], [1, 1, 5],
+            [1, 2, 2], [1, 2, 3], [1, 2, 4], [1, 2, 5],
+            [1, 3, 3], [1, 3, 4], [1, 3, 5],
+            [1, 4, 4], [1, 4, 5],
+            [1, 5, 5],
+            [2, 2, 2], [2, 2, 3], [2, 2, 4], [2, 2, 5],
+            [2, 3, 3], [2, 3, 4], [2, 3, 5],
+            [2, 4, 4], [2, 4, 5],
+            [2, 5, 5],
+            [3, 3, 3], [3, 3, 4], [3, 3, 5],
+            [3, 4, 4], [3, 4, 5],
+            [3, 5, 5],
+            [4, 4, 4], [4, 4, 5],
+            [4, 5, 5],
+            [5, 5, 5] ]
+
+    c = GSL::Multiset.alloc(6, 3)
+    c.init_first
+
+    status = i = 0
+
+    loop {
+      if i >= 56
+        status = 1
+        break
+      end
+
+      3.times { |j| status |= c.data[j] != c63[i][j] ? 0 : 1 }
+      assert c.valid, "gsl_multiset_valid(#{i})"
+
+      i += 1
+
+      break if c.next != GSL::SUCCESS
+    }
+
+    refute status.zero?
+  end
+
+end

data/test/gsl/odeiv_test.rb

@@ -0,0 +1,275 @@
+require 'test_helper'
+
+class OdeivTest < GSL::TestCase
+
+  def setup
+    @rhs_func_lin = GSL::Odeiv::System.alloc(lambda { |t, y, f|
+      f[0] = 0.0
+      f[1] = y[0]
+      GSL::SUCCESS
+    }, lambda { |t, y, dfdy, dfdt|
+      dfdy.set(0, 0, 0.0)
+      dfdy.set(0, 1, 0.0)
+      dfdy.set(1, 0, 1.0)
+      dfdy.set(1, 1, 0.0)
+      dfdt[0] = 0.0
+      dfdt[1] = 0.0
+      GSL::SUCCESS
+    }, 2)
+
+    @rhs_func_sin = GSL::Odeiv::System.alloc(lambda { |t, y, f|
+      f[0] = -y[1]
+      f[1] = y[0]
+      GSL::SUCCESS
+    }, lambda { |t, y, dfdy, dfdt|
+      dfdy.set(0, 0, 0.0)
+      dfdy.set(0, 1, -1.0)
+      dfdy.set(1, 0, 1.0)
+      dfdy.set(1, 1, 0.0)
+      dfdt[0] = 0.0
+      dfdt[1] = 0.0
+      GSL::SUCCESS
+    }, 2)
+
+    @rhs_func_exp = GSL::Odeiv::System.alloc(lambda { |t, y, f|
+      f[0] = y[1]
+      f[1] = y[0]
+      GSL::SUCCESS
+    }, lambda { |t, y, dfdy, dfdt|
+      dfdy.set(0, 0, 0.0)
+      dfdy.set(0, 1, 1.0)
+      dfdy.set(1, 0, 1.0)
+      dfdy.set(1, 1, 0.0)
+      dfdt[0] = 0.0
+      dfdt[1] = 0.0
+      GSL::SUCCESS
+    }, 2)
+
+    @rhs_func_stiff = GSL::Odeiv::System.alloc(lambda { |t, y, f|
+      f[0] = 998.0 * y[0] + 1998.0 * y[1]
+      f[1] = -999.0 * y[0] - 1999.0 * y[1]
+      GSL::SUCCESS
+    }, lambda { |t, y, dfdy, dfdt|
+      dfdy.set(0, 0, 998.0)
+      dfdy.set(0, 1, 1998.0)
+      dfdy.set(1, 0, -999.0)
+      dfdy.set(1, 1, -1999.0)
+      dfdt[0] = 0.0
+      dfdt[1] = 0.0
+      GSL::SUCCESS
+    }, 2)
+  end
+
+  def self.define_test(test, type, h, b)
+    define_method("test_#{test}_#{type}") { send("_test_#{test}", type, h, b) }
+  end
+
+  h, b = 1e-3, GSL::SQRT_DBL_EPSILON
+  h2, b2 = h / 10, 1e-8
+
+  %w[rk2 rk2imp rk4 rk4imp rkf45 rk8pd rkck bsimp gear1 gear2].each { |type|
+    define_test(:stepper_err, type, h, b) unless type == 'bsimp'
+
+    unless type == 'gear2'
+      define_test(:stepper_linear, type, h,  b)
+      define_test(:stepper_sin,    type, h2, b2)
+      define_test(:stepper_exp,    type, h2, b2)
+      define_test(:stepper_stiff,  type, h,  b)
+    end
+
+    define_test(:evolve_sin,    type, h, b)
+    define_test(:evolve_exp,    type, h, b)
+    define_test(:evolve_stiff1, type, h, b)
+    define_test(:evolve_stiff5, type, h, b)
+  }
+
+  def _test_stepper_err(type, h, b)
+    t = 0.0
+
+    y = GSL::Vector.alloc(1.0, 0.0)
+    yerr = GSL::Vector.alloc(2)
+
+    stepper = GSL::Odeiv::Step.alloc(type, 2)
+
+    while t < GSL::M_PI
+      y1_t = y[1]
+      dy_exp = Math.cos(t) * Math.sin(h) - 2 * Math.sin(t) * GSL.pow(Math.sin(h / 2), 2.0)
+
+      stepper.apply(t, h, y, yerr, @rhs_func_sin)
+
+      dy_t = y[1] - y1_t
+      del = (dy_t - dy_exp).abs
+
+      refute t > 0.1 && t < 0.2 && del > 10.0 * yerr[1].abs + GSL::DBL_EPSILON * y[1].abs,
+        "#{stepper.name}, sine [0,pi], accurary of estimate error = #{del} vs #{yerr[1].abs}"
+
+      t += h
+    end
+  end
+
+  def _test_stepper_linear(type, h, b)
+    delmax, n, t = 0.0, 0, 0.0
+
+    stepper = GSL::Odeiv::Step.alloc(type, 2)
+
+    y = GSL::Vector.alloc(1.0, 0.0)
+    yerr = GSL::Vector.alloc(2)
+
+    while t < 4.0
+      stepper.apply(t, h, y, yerr, @rhs_func_lin)
+
+      del = ((y[1] - (t + h)) / y[1]).abs
+      delmax = GSL.MAX_DBL(del, delmax)
+
+      refute del > (n + 1.0) * b,
+        "#{stepper.name}, linear [0,4], max relative error = #{delmax}"
+
+      n += 1
+      t += h
+    end
+  end
+
+  def _test_stepper_sin(type, h, b)
+    delmax, n, t, pi = 0.0, 0, 0.0, GSL::M_PI
+
+    stepper = GSL::Odeiv::Step.alloc(type, 2)
+
+    y = GSL::Vector.alloc(1.0, 0.0)
+    yerr = GSL::Vector.alloc(2)
+
+    while t < pi
+      sin_th = Math.sin(t + h)
+      stepper.apply(t, h, y, yerr, @rhs_func_sin)
+
+      del = ((y[1] - sin_th) / sin_th).abs
+      delmax = GSL.MAX_DBL(del, delmax)
+
+      refute del > (
+        t < 0.5 * pi ? 1.0 + n :
+        t < 0.7 * pi ? 1.0e+04 :
+        t < 0.9 * pi ? 1.0e+06 : 1.0e+09) * b,
+        "#{stepper.name}, sine [0,pi], max relative error = #{delmax}"
+
+      n += 1
+      t += h
+    end
+
+    refute delmax > 1.0e+09 * b,
+      "#{stepper.name}, sine [0,pi], max relative error = #{delmax}"
+
+    delmax = 0.0
+
+    while t < 3 * pi
+      stepper.apply(t, h, y, yerr, @rhs_func_sin)
+
+      del = (y[1] - Math.sin(t)).abs
+      delmax = GSL.MAX_DBL(del, delmax)
+
+      n += 1
+      t += h
+    end
+
+    refute del > n * 2.0 * b,
+      "#{stepper.name}, sin [pi,3*pi], max absolute error = #{delmax}"
+  end
+
+  def _test_stepper_exp(type, h, b)
+    delmax, n, t = 0.0, 0, 0.0
+
+    stepper = GSL::Odeiv::Step.alloc(type, 2)
+
+    y = GSL::Vector.alloc(1.0, 1.0)
+    yerr = GSL::Vector.alloc(2)
+
+    while t < 5.0
+      stepper.apply(t, h, y, yerr, @rhs_func_exp)
+
+      del = ((y[1] - Math.exp(t + h)) / y[1]).abs
+      delmax = GSL.MAX_DBL(del, delmax)
+
+      refute del > (n + 1.0) * 2.0 * b,
+        "#{stepper.name}, exponential [0,5], max relative error = #{delmax}"
+
+      n += 1
+      t += h
+    end
+  end
+
+  def _test_stepper_stiff(type, h, b)
+    delmax, n, t = 0.0, 0, 0.0
+
+    stepper = GSL::Odeiv::Step.alloc(type, 2)
+
+    y = GSL::Vector.alloc(1.0, 0.0)
+    yerr = GSL::Vector.alloc(2)
+
+    while t < 5.0
+      stepper.apply(t, h, y, yerr, @rhs_func_stiff)
+
+      if t > 0.04
+        arg = t + h
+
+        e1 = Math.exp(-arg)
+        e2 = Math.exp(-1000.0 * arg)
+
+        del = ((y[0] - 2.0 * e1 + e2) / y[0]).abs
+        delmax = GSL.MAX_DBL(del, delmax)
+
+        refute del > (n + 1.0) * 100.0 * b,
+          "#{stepper.name}, stiff [0,5], max relative error = #{delmax}"
+      end
+
+      n += 1
+      t += h
+    end
+  end
+
+  def _test_evolve_system_flat(type, sys, t0, t1, h, y, yfin, err_target, desc, control = nil)
+    stepper = GSL::Odeiv::Step.alloc(type, sys.dimension)
+    evolve  = GSL::Odeiv::Evolve.alloc(sys.dimension)
+
+    while t0 < t1
+      t0, h, _ = evolve.apply(control, stepper, sys, t0, t1, h, y)
+    end
+
+    frac = ((y[1] - yfin[1]) / yfin[1]).abs + ((y[0] - yfin[0]) / yfin[0]).abs
+    refute frac > 2.0 * evolve.count * err_target, "#{stepper.name}, #{desc}, evolve" <<
+      ", #{control ? 'standard' : 'no'} control, relative error = #{frac}"
+  end
+
+  def _test_evolve_system(type, sys, t0, t1, h, y, yfin, err_target, desc)
+    _test_evolve_system_flat(type, sys, t0, t1, h, y, yfin, err_target, desc,
+      GSL::Odeiv::Control.standard_alloc(0.0, err_target, 1.0, 1.0))
+  end
+
+  def _test_evolve_sin(type, h, err)
+    y = GSL::Vector.alloc(1.0, 0.0)
+    yfin = GSL::Vector.alloc(Math.cos(2.0), Math.sin(2.0))
+
+    _test_evolve_system(type, @rhs_func_sin, 0.0, 2.0, h, y, yfin, err, 'sin [0,2]')
+  end
+
+  def _test_evolve_exp(type, h, err)
+    eee = Math.exp(5.0)
+
+    y = GSL::Vector.alloc(1.0, 1.0)
+    yfin = GSL::Vector.alloc(eee, eee)
+
+    _test_evolve_system(type, @rhs_func_exp, 0.0, 5.0, h, y, yfin, err, 'exp [0,5]')
+  end
+
+  def _test_evolve_stiff1(type, h, err, arg = 1.0)
+    e1 = Math.exp(-arg)
+    e2 = Math.exp(-1000.0 * arg)
+
+    y = GSL::Vector.alloc(1.0, 0.0)
+    yfin = GSL::Vector.alloc(2.0 * e1 - e2, -e1 + e2)
+
+    _test_evolve_system(type, @rhs_func_stiff, 0.0, arg, h, y, yfin, err, 'stiff [0,%d]' % arg)
+  end
+
+  def _test_evolve_stiff5(type, h, err)
+    _test_evolve_stiff1(type, h, err, 5.0)
+  end
+
+end