gsl 1.12.109 → 1.14.5

data/examples/min.rb

@@ -0,0 +1,29 @@
+#!/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

@@ -0,0 +1,47 @@
+#!/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

@@ -0,0 +1,47 @@
+#!/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

@@ -0,0 +1,47 @@
+#!/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

@@ -0,0 +1,46 @@
+#!/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

@@ -0,0 +1,66 @@
+#!/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

@@ -0,0 +1,109 @@
+#!/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

@@ -0,0 +1,40 @@
+#!/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

@@ -0,0 +1,41 @@
+#!/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
+