rb-gsl 1.16.0.5 → 1.16.0.6

data/examples/min.rb

@@ -1,29 +0,0 @@
-#!/usr/bin/env ruby
-require("gsl")
-fn1 = GSL::Function.alloc { |x| Math::cos(x) + 1.0 }
-iter = 0;  max_iter = 500
-m = 2.0             # initial guess
-m_expected = Math::PI
-a = 0.0; b = 6.0
-gmf = GSL::Min::FMinimizer.alloc(GSL::Min::FMinimizer::BRENT)
-gmf.set(fn1, m, a, b)
-printf("Using %s method\n", gmf.name)
-printf("%5s [%9s, %9s] %9s %10s %9s\n", "iter", "lower", "upper", "min",
-       "err", "err(est)")
-printf("%5d [%.7f, %.7f] %.7f %+.7f %.7f\n",
-       iter, a, b, m, m - m_expected, b - a)
-begin
-  iter += 1
-  status = gmf.iterate
-  status = gmf.test_interval(0.001, 0.0)
-  puts("Converged:") if status == GSL::SUCCESS
-  a = gmf.x_lower;  b = gmf.x_upper
-  m = gmf.x_minimum
-  printf("%5d [%.7f, %.7f] %.7f %+.7f %.7f\n",
-         iter, a, b, m, m - m_expected, b - a);
-end while status == GSL::CONTINUE and iter < max_iter
-
-x = GSL::Vector.linspace(0, 6, 50)
-mx = gmf.x_minimum
-min = fn1.eval(mx)
-GSL::graph([x, fn1.eval(x)], [GSL::Vector[mx], GSL::Vector[min]], "-C -g 3 -S 4 -m -1")

data/examples/monte/miser.rb

@@ -1,47 +0,0 @@
-#!/usr/bin/env ruby
-require("gsl")
-include GSL
-include Monte
-include Math
-
-proc_f = Proc.new { |k, dim, params|
-  pi = Math::PI
-  a = 1.0/(pi*pi*pi)
-  a/(1.0 - cos(k[0])*cos(k[1])*cos(k[2]))
-}
-
-def display_results(title, result, error)
-  exact = 1.3932039296856768591842462603255
-
-  diff = result - exact
-  printf("%s ==================\n", title);
-  printf("result = % .6f\n", result);
-  printf("sigma  = % .6f\n", error);
-  printf("exact  = % .6f\n", exact);
-  printf("error  = % .6f = %.1g sigma\n", diff, diff.abs/error)
-end
-
-dim = 3
-xl = Vector.alloc([0, 0, 0])
-xu = Vector.alloc([PI, PI, PI])
-G = Monte::Function.alloc(proc_f, dim)
-calls = 10000
-r = GSL::Rng.alloc(Rng::DEFAULT)
-
-miser = Monte::Miser.alloc(dim)
-
-result, error = Monte::Miser::integrate(G, xl, xu, dim, calls, r, miser)
-#result, error = Monte::Miser::integrate(G, xl, xu, calls, r, miser)
-#result, error = Monte::Miser::integrate(G, xl, xu, calls, miser)
-#result, error = Monte::Miser::integrate(G, xl, xu, dim, calls, r, "miser")
-
-#result, error = G.integrate(xl, xu, dim, calls, r, miser)
-#result, error = G.integrate(xl, xu, calls, r, miser)
-#result, error = G.integrate(xl, xu, calls, miser)
-
-#result, error = miser.integrate(G, xl, xu, dim, calls, r)
-#result, error = miser.integrate(G, xl, xu, calls, r)
-#result, error = miser.integrate(G, xl, xu, dim, calls)
-#result, error = miser.integrate(G, xl, xu, calls)
-
-display_results("miser", result, error)

data/examples/monte/monte.rb

@@ -1,47 +0,0 @@
-#!/usr/bin/env ruby
-require("gsl")
-include GSL
-include Monte
-include Math
-
-proc_f = Proc.new { |k, dim, params|
-  pi = Math::PI
-  a = 1.0/(pi*pi*pi)
-  a/(1.0 - cos(k[0])*cos(k[1])*cos(k[2]))
-}
-
-def display_results(title, result, error)
-  exact = 1.3932039296856768591842462603255
-
-  diff = result - exact
-  printf("%s ==================\n", title);
-  printf("result = % .6f\n", result);
-  printf("sigma  = % .6f\n", error);
-  printf("exact  = % .6f\n", exact);
-  printf("error  = % .6f = %.1g sigma\n", diff, diff.abs/error)
-end
-
-dim = 3
-xl = Vector.alloc([0, 0, 0])
-xu = Vector.alloc([PI, PI, PI])
-G = Monte::Function.alloc(proc_f, dim)
-calls = 500000
-r = GSL::Rng.alloc(Rng::DEFAULT)
-
-plain = Monte::Plain.alloc(dim)
-result, error = G.integrate(xl, xu, dim, calls, r, plain)
-display_results("plain", result, error)
-
-miser = Monte::Miser.alloc(dim)
-result, error = G.integrate(xl, xu, dim, calls, r, miser)
-display_results("miser", result, error)
-
-vegas = Monte::Vegas.alloc(dim)
-result, error = G.integrate(xl, xu, dim, 10000, r, vegas)
-display_results("vegas warm-up", result, error)
-puts("converging...");
-begin
-  result, error = G.integrate(xl, xu, dim, calls/5, r, vegas)
-  printf("result = % .6f sigma = % .6f chisq/dof = %.1f\n", result, error, vegas.chisq)
-end while (vegas.chisq-1.0).abs > 0.5
-display_results("vegas final", result, error)

data/examples/monte/plain.rb

@@ -1,47 +0,0 @@
-#!/usr/bin/env ruby
-require("gsl")
-include GSL
-include Monte
-include Math
-
-proc_f = Proc.new { |k, dim, params|
-  pi = Math::PI
-  a = 1.0/(pi*pi*pi)
-  a/(1.0 - cos(k[0])*cos(k[1])*cos(k[2]))
-}
-
-def display_results(title, result, error)
-  exact = 1.3932039296856768591842462603255
-
-  diff = result - exact
-  printf("%s ==================\n", title);
-  printf("result = % .6f\n", result);
-  printf("sigma  = % .6f\n", error);
-  printf("exact  = % .6f\n", exact);
-  printf("error  = % .6f = %.1g sigma\n", diff, diff.abs/error)
-end
-
-dim = 3
-xl = Vector.alloc([0, 0, 0])
-xu = Vector.alloc([PI, PI, PI])
-G = Monte::Function.alloc(proc_f, dim)
-calls = 10000
-r = GSL::Rng.alloc(Rng::DEFAULT)
-
-plain = Monte::Plain.alloc(dim)
-
-result, error = Monte::Plain::integrate(G, xl, xu, dim, calls, r, plain)
-#result, error = Monte::Plain::integrate(G, xl, xu, calls, r, plain)
-#result, error = Monte::Plain::integrate(G, xl, xu, calls, plain)
-#result, error = Monte::Plain::integrate(G, xl, xu, dim, calls, r, "plain")
-
-#result, error = G.integrate(xl, xu, dim, calls, r, plain)
-#result, error = G.integrate(xl, xu, calls, r, plain)
-#result, error = G.integrate(xl, xu, calls, plain)
-
-#result, error = plain.integrate(G, xl, xu, dim, calls, r)
-#result, error = plain.integrate(G, xl, xu, calls, r)
-#result, error = plain.integrate(G, xl, xu, dim, calls)
-#result, error = plain.integrate(G, xl, xu, calls)
-
-display_results("plain", result, error)

data/examples/monte/vegas.rb

@@ -1,46 +0,0 @@
-#!/usr/bin/env ruby
-require("gsl")
-include GSL
-include Monte
-include Math
-
-proc_f = Proc.new { |k, dim, params|
-  pi = Math::PI
-  a = 1.0/(pi*pi*pi)
-  a/(1.0 - cos(k[0])*cos(k[1])*cos(k[2]))
-}
-
-def display_results(title, result, error)
-  exact = 1.3932039296856768591842462603255
-
-  diff = result - exact
-  printf("%s ==================\n", title);
-  printf("result = % .6f\n", result);
-  printf("sigma  = % .6f\n", error);
-  printf("exact  = % .6f\n", exact);
-  printf("error  = % .6f = %.1g sigma\n", diff, diff.abs/error)
-end
-
-dim = 3
-xl = Vector.alloc([0, 0, 0])
-xu = Vector.alloc([PI, PI, PI])
-G = Monte::Function.alloc(proc_f, dim)
-calls = 10000
-r = GSL::Rng.alloc(Rng::DEFAULT)
-
-vegas = Monte::Vegas.alloc(dim)
-result, error = Monte::Vegas::integrate(G, xl, xu, dim, calls, r, vegas)
-#result, error = Monte::Vegas::integrate(G, xl, xu, calls, r, vegas)
-#result, error = Monte::Vegas::integrate(G, xl, xu, calls, vegas)
-#result, error = Monte::Vegas::integrate(G, xl, xu, dim, calls, r, "vegas")
-
-#result, error = G.integrate(xl, xu, dim, calls, r, vegas)
-#result, error = G.integrate(xl, xu, calls, r, vegas)
-#result, error = G.integrate(xl, xu, calls, vegas)
-
-#result, error = vegas.integrate(G, xl, xu, dim, calls, r)
-#result, error = vegas.integrate(G, xl, xu, calls, r)
-#result, error = vegas.integrate(G, xl, xu, dim, calls)
-#result, error = vegas.integrate(G, xl, xu, calls)
-
-display_results("vegas", result, error)

data/examples/multimin/bundle.rb

@@ -1,66 +0,0 @@
-#!/usr/bin/env ruby
-require("gsl")
-
-demyanov_f = Proc.new { |x, params|
-  GSL::MAX_DBL(5.0*x[0]+x[1], GSL::MAX_DBL(x[0]*x[0]+x[1]*x[1]+4.0*x[1], -5.0*x[0] + x[1]))
-}
-
-demyanov_sdf = Proc.new { |x, sdf|
-  f = 5.0*x[0] + x[1]
-  ff = x[0]*x[0] + x[1]*x[1] + 4.0*x[1]
-  i_max = 1
-  if f < ff
-    f = ff
-    i_max = 2
-  end
-  if f < -5.0*x[0] + x[1]
-    i_max = 3
-  end
-  case i_max
-  when 1
-    sdf[0] = 5.0
-    sdf[1] = 1.0
-  when 2
-    sdf[0] = 2.0*x[0]
-    sdf[1] = 2.0*x[1] + 4.0
-  when 3
-    sdf[0] = -5.0
-    sdf[1] = 1.0
-  end
-}
-
-max_iter = 1000
-n = 2
-function = GSL::MultiMin::Function_fsdf.alloc(demyanov_f, demyanov_sdf, n)
-
-start_point = GSL::Vector.alloc(n)
-start_point.set_all(1.0)
-bundle_size_max = n + 3
-
-s = GSL::MultiMin::FsdfMinimizer.alloc("bundle_method", n)
-s.set(function, start_point, bundle_size_max)
-
-printf("********************  %s  ********************\n\n","Demyanov function")
-
-printf("== k ===== f(x) ===== ||sgr_f(x)|| ======= eps ======  \n");
-
-subgradient = s.subgradient
-
-iter = 0;
-printf("%4d  %14.7f  %13.8e  %13.8e\n", iter, s.f, subgradient.dnrm2, s.eps)
-
-begin
-  iter += 1
-  status = s.iterate
-  status = s.test_convergence(1e-5)
-  printf("%4d  %14.7f  %13.8e  %13.8e\n", iter, s.f, subgradient.dnrm2, s.eps)
-  if status == GSL::SUCCESS
-    printf("\nMinimum is found at\n")
-    x = s.x
-    for j in 0...x.size do
-      printf("%9.6f ", x[j])
-    end
-    printf("\n\n")
-  end
-end while status == GSL::CONTINUE and iter <= max_iter
-

data/examples/multimin/cqp.rb

@@ -1,109 +0,0 @@
-#!/usr/bin/env ruby
-require("gsl")
-
-module GSL::CQP
-  class Test_Problem
-    def Test_Problem.gould()
-      cqp_data = GSL::CQP::Data.alloc()
-      cqp_data.Q = GSL::Matrix.eye(2, 2)
-      cqp_data.q = GSL::Vector[-2.0, -1.0]
-      cqp_data.A = GSL::Matrix[[3, 1], 1, 2]
-      cqp_data.b = GSL::Vector.alloc(1); cqp_data.b[0] = 1.5
-      cqp_data.C = GSL::Matrix[[1, 0, 0, 1], 2, 2]
-      cqp_data.d = GSL::Vector.calloc(2)
-
-      Test_Problem.new("Goulds's problem", 2, 1, 2, cqp_data, 0.0)
-    end
-    def Test_Problem.betts()
-      cqp_data = GSL::CQP::Data.alloc()
-      cqp_data.Q = GSL::Matrix[[0.02, 0, 0, 2], 2, 2]
-      cqp_data.q = GSL::Vector.calloc(2)
-      cqp_data.A = GSL::Matrix[[10, -1.0], 1, 2]
-      cqp_data.b = GSL::Vector.alloc(1); cqp_data.b[0] = 20
-      cqp_data.C = GSL::Matrix.calloc(4, 2)
-      cqp_data.C[0,0] = 1.0; cqp_data.C[1,1] = 1.0
-      cqp_data.C[2,0] = -1.0; cqp_data.C[3,1] = -11.0
-      cqp_data.d = GSL::Vector[2.0, -50, -50, -50]
-
-
-      Test_Problem.new("Betts's problem", 2, 1, 4, cqp_data, 0.04)
-    end
-    def Test_Problem.beale()
-      cqp_data = GSL::CQP::Data.alloc()
-      cqp_data.Q = GSL::Matrix[[4, 2, 2, 2, 4, 0, 2, 0, 2], 3, 3]
-      cqp_data.q = GSL::Vector[-8, -6, -4]
-      cqp_data.A = GSL::Matrix[[-1, -1, -2], 1, 3]
-      cqp_data.b = GSL::Vector.alloc(1); cqp_data.b[0] = -3.0
-      cqp_data.C = GSL::Matrix.eye(3, 3)
-      cqp_data.d = GSL::Vector.calloc(3)
-
-      cqp_data.Q[0,0] = 4.0; cqp_data.Q[0,1] = 2.0
-      cqp_data.Q[1,0] = 2.0; cqp_data.Q[1,1] = 4.0
-      cqp_data.Q[2,0] = 2.0; cqp_data.Q[2,2] = 2.0
-      Test_Problem.new("Beale's problem", 3, 1, 3, cqp_data, 9.0+1.0/9.0)
-    end
-
-    def initialize(name, n, me, mi, cqp, opt_value)
-      @name = name
-      @n = n
-      @me = me
-      @mi = mi
-      @cqp = cqp
-      @opt_value = opt_value
-    end
-
-    def solve()
-      max_iter = 1000
-      iter = 1
-      status = GSL::CONTINUE
-      s = GSL::CQP::Minimizer.alloc("mg_pdip", @n, @me, @mi)
-      s.set(@cqp)
-      printf("********************  %s  ********************\n\n", @name)
-
-      printf("== Itn ======= f ======== ||gap|| ==== ||residual||\n\n")
-
-      begin
-        status = s.iterate
-        status = s.test_convergence(1e-10, 1e-10)
-        printf("%4d   %14.8f  %13.6e  %13.6e\n", iter, s.f, s.gap, s.residuals_norm)
-        if status == GSL::SUCCESS
-          printf("\nMinimum is found at\n");
-          x = s.x
-          lm_eq = s.lm_eq
-          lm_ineq = s.lm_ineq
-          for j in 0...x.size do
-            printf("%9.6f ", x[j])
-          end
-          printf("\n\n")
-          printf("\nLagrange-multipliers for Ax=b\n")
-          for j in 0...lm_eq.size do
-            printf("%9.6f ", lm_eq[j])
-          end
-          printf("\n\n")
-          printf("\nLagrange-multipliers for Cx>=d\n");
-          for j in 0...lm_ineq.size do
-            printf("%9.6f ", lm_ineq[j])
-          end
-          printf("\n\n")
-        else
-          iter += 1
-        end
-     end while status == GSL::CONTINUE and iter <= max_iter
-      GSL::SUCCESS
-    end
-
-    attr_accessor :name, :n, :me, :mi
-    attr_accessor :cqp, :opt_value
-  end
-
-end
-
-tp = Array.new(3)
-tp[0] = GSL::CQP::Test_Problem.gould()
-tp[1] = GSL::CQP::Test_Problem.betts()
-tp[2] = GSL::CQP::Test_Problem.beale()
-
-tp.each do |t|
-  t.solve()
-end
-

data/examples/multimin/fdfminimizer.rb

@@ -1,40 +0,0 @@
-#!/usr/bin/env ruby
-require("gsl")
-include GSL::MultiMin
-
-my_f = Proc.new { |v, params|
-  x = v[0]; y = v[1]
-  p0 = params[0]; p1 = params[1]
-  10.0*(x - p0)*(x - p0) + 20.0*(y - p1)*(y - p1) + 30.0
-}
-
-my_df = Proc.new { |v, params, df|
-  x = v[0]; y = v[1]
-  p0 = params[0]; p1 = params[1]
-  df[0] = 20.0*(x-p0)
-  df[1] = 40.0*(y-p1)
-}
-
-my_func = GSL::MultiMin::Function_fdf.alloc(my_f, my_df, 2)
-my_func.set_params([1.0, 2.0])      # parameters
-
-x = GSL::Vector.alloc([5.0, 7.0])          # starting point
-
-#minimizer = GSL::MultiMin::FdfMinimizer.alloc("conjugate_fr", 2)
-minimizer = GSL::MultiMin::FdfMinimizer.alloc(GSL::MultiMin::FdfMinimizer::VECTOR_BFGS, 2)
-#minimizer = GSL::MultiMin::FdfMinimizer.alloc(GSL::MultiMin::FdfMinimizer::VECTOR_BFGS2, 2)
-minimizer.set(my_func, x, 0.01, 1e-4)
-
-iter = 0
-begin
-  iter += 1
-  status = minimizer.iterate()
-  status = minimizer.test_gradient(1e-3)
-  if status == GSL::SUCCESS
-    puts("Minimum found at")
-  end
-  x = minimizer.x
-  f = minimizer.f
-  printf("%5d %.5f %.5f %10.5f\n", iter, x[0], x[1], f)
-
-end while status == GSL::CONTINUE and iter < 100

data/examples/multimin/fminimizer.rb

@@ -1,41 +0,0 @@
-#!/usr/bin/env ruby
-require("gsl")
-include GSL
-include GSL::MultiMin
-
-np = 2
-
-my_f = Proc.new { |v, params|
-  x = v[0]; y = v[1]
-  p0 = params[0]; p1 = params[1]
-  10.0*(x - p0)*(x - p0) + 20.0*(y - p1)*(y - p1) + 30.0
-}
-
-my_func = MultiMin::Function.alloc(my_f, np)
-my_func.set_params([1.0, 2.0])      # parameters
-
-x = Vector.alloc([5, 7])
-ss = Vector.alloc(np)
-ss.set_all(1.0)
-
-#minimizer = FMinimizer.alloc("nmsimplex", np)
-minimizer = FMinimizer.alloc(MultiMin::FMinimizer::NMSIMPLEX, np)
-
-minimizer.set(my_func, x, ss)
-
-iter = 0
-begin
-  iter += 1
-  status = minimizer.iterate()
-  status = minimizer.test_size(1e-2)
-  if status == GSL::SUCCESS
-    puts("converged to minimum at")
-  end
-  x = minimizer.x
-  printf("%5d ", iter);
-  for i in 0...np do
-    printf("%10.3e ", x[i])
-  end
-  printf("f() = %7.3f size = %.3f\n", minimizer.fval, minimizer.size);
-end while status == GSL::CONTINUE and iter < 100
-