rb-gsl 1.15.3.1

data/examples/fit/plot.gp

@@ -0,0 +1,36 @@
+#!/usr/bin/gnuplot
+
+set terminal postscript eps enhanced color 18
+
+set pm3d map
+#set palette gray
+set palette
+#set palette gamma 0.5
+set xrange [0:3]
+set yrange [0:3]
+set cbrange [-4:5]
+set ytics border nomirror
+
+set output "ndlinear.eps"
+set xlabel "r"
+set ylabel "{/Symbol \161}"
+
+set colorbox horizontal user origin 0.1,0.05 size 1.8,0.05
+
+set size 2.0, 1.1
+set multiplot
+
+set size 1.0, 1.0
+set origin 0, 0.1
+set title "Exact solution"
+unset key
+splot 'ndlinear.dat' us 1:2:3
+
+unset colorbox
+
+set size 1.0, 1.0
+set origin 1, 0.1
+set title "Model solution"
+splot 'ndlinear.dat' us 1:2:4
+
+unset multiplot

data/examples/fit/polyfit.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+x = GSL::Vector[0.0, 0.3, 0.8, 1.1, 1.6, 2.3]
+y = GSL::Vector[0.5, 0.82, 1.14, 1.25, 1.35, 1.40]
+coef, cov, chisq, status = GSL::MultiFit.polyfit(x, y, 2)
+p coef
+x2 = GSL::Vector.linspace(0, 2.5, 20)
+GSL::graph([x, y], [x2, coef.eval(x2)], "-C -g 3 -S 4 -X X -Y Y")

data/examples/fit/powerfit.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+N = 100
+
+y0 = 0.1
+A = 2
+rr = -1.5
+
+r = GSL::Rng.alloc()
+x = GSL::Vector.linspace(0.1, 1, N)
+y =  y0 + A*GSL::pow(x, rr) + 0.1*r.gaussian(1, N)
+
+coef, err, chi2, dof = GSL::MultiFit::FdfSolver.fit(x, y, "power")
+y0 = coef[0]
+amp = coef[1]
+rr = coef[2]
+p coef
+p err
+
+GSL::graph(x, y, y0+amp*GSL::pow(x, rr), "-T X -C -g 3 -l x -l y")

data/examples/fit/sigmoidfit.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+N = 100
+
+y0 = 0.5
+m = 1.0
+x0 = 1
+rr = 0.2
+
+r = GSL::Rng.alloc()
+x = GSL::Vector.linspace(0, 2, N)
+y =  y0 + m/(1.0 + GSL::Sf::exp((x0-x)/rr)) + 0.02*r.gaussian(1, N)
+
+coef, err, chi2, dof = GSL::MultiFit::FdfSolver.fit(x, y, "sigmoid")
+y0 = coef[0]
+m = coef[1]
+x0 = coef[2]
+rr = coef[3]
+p coef
+p err
+GSL::graph(x, y, y0+m/(1+GSL::Sf::exp((x0-x)/rr)))
+
+=begin
+Result:
+GSL::Vector
+[ 4.954e-01 1.004e+00 9.916e-01 1.991e-01 ]
+GSL::Vector
+[ 5.653e-03 9.100e-03 5.033e-03 4.856e-03 ]
+
+GNUPLOT result:
+Final set of parameters            Asymptotic Standard Error
+=======================            ==========================
+
+y0              = 0.495446         +/- 0.005656     (1.142%)
+m               = 1.00422          +/- 0.009105     (0.9067%)
+x0              = 0.991588         +/- 0.005033     (0.5076%)
+r               = 0.199059         +/- 0.00486      (2.442%)
+
+=end

data/examples/fit/sinfit.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+N = 100
+
+y0 = 1
+A = 1.5
+fc = 0.7
+phi = 0.2
+
+r = GSL::Rng.alloc()
+x = GSL::Vector.linspace(0, 12, N)
+y =  y0 + A*GSL::Sf::sin(fc*x+phi) + 0.1*r.gaussian(1, N)
+
+coef, err, chi2, dof = GSL::MultiFit::FdfSolver.fit(x, y, "sin")
+y0 = coef[0]
+amp = coef[1]
+fc = coef[2]
+phi = coef[3]
+p coef
+p err
+GSL::graph(x, y, y0+amp*GSL::Sf::sin(fc*x+phi))

data/examples/fit/wlinear.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+n = 4
+x = GSL::Vector[1970.0, 1980, 1990, 2000]
+y = GSL::Vector[12.0, 11, 14, 13]
+w = GSL::Vector[0.1, 0.2, 0.3, 0.4]
+
+c0, c1, cov00, cov01, cov11, chisq = GSL::Fit::wlinear(x, w, y)
+
+printf("# best fit: Y = %g + %g X\n", c0, c1);
+printf("# covariance matrix:\n");
+printf("# [ %g, %g\n#   %g, %g]\n", 
+        cov00, cov01, cov01, cov11);
+printf("# chisq = %g\n", chisq);
+
+File.open("data.dat", "w") do |f|
+  for i in 0...n do
+    f.printf("%e %e %e\n", x[i], y[i], 1.0/Math::sqrt(w[i]))
+  end
+end
+
+begin
+  ffit = File.open("fit.dat", "w")
+  fhi = File.open("hi.dat", "w")
+  flo = File.open("lo.dat", "w")
+  for i in -30...130 do
+    xf = x[0] + (i/100.0) * (x[n-1] - x[0])
+    
+    yf, yf_err = GSL::Fit::linear_est(xf, c0, c1, cov00, cov01, cov11)
+    
+    ffit.printf("%g %g\n", xf, yf)
+    fhi.printf("%g %g\n", xf, yf + yf_err)
+    flo.printf("%g %g\n", xf, yf - yf_err)
+  end
+ensure
+  ffit.close
+  fhi.close
+  flo.close
+end
+
+system("graph -T X -C -g 3 -X x -Y y -x 1960 2010 -y 0 20 -m 0 -S 2 -Ie data.dat -S 0 -I a -m 1 fit.dat -m 2 hi.dat -m 2 lo.dat")
+File.delete("data.dat")
+File.delete("fit.dat")
+File.delete("hi.dat")
+File.delete("lo.dat")

data/examples/fresnel.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+# Abramovitz & Stegun
+fc01 = 0.0999975
+fs01 = 0.0005236
+
+printf("fresnel_c(0.1):\n")
+printf("Expect: %2.7f \t Calculated: %2.7f \n ", fc01, GSL::fresnel_c(0.1))
+printf("fresnel_s(0.1):\n")
+printf("Expect: %2.7f \t Calculated: %2.7f \n ", fs01, GSL::fresnel_s(0.1))

data/examples/function/function.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+require("gsl")
+include Math
+
+f = GSL::Function::alloc{ |x, params| 
+  a = params[0]
+  b = params[1]
+  c = params[2]
+  (a*x + b)*x + c
+}
+
+p f.proc
+p f.params
+a = 1; b = 2; c = 3
+f.set_params(a, b, c)
+p f.params
+
+p f.eval(2)
+p f.call(4)
+
+
+f.set { |x|
+  x*x*x
+}
+
+p f.params
+
+p f.eval(2)
+p f[4]
+
+f2 = GSL::Function.alloc { |x|
+  sin(x) - log(x)*sqrt(x)
+}
+
+p f2.eval(2.5)
+p f2.arity

data/examples/function/log.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+f_log = GSL::Function.alloc { |x| Math::log(x) }
+x = GSL::Vector.linspace(1, 100, 10)
+x2 = GSL::Vector.logspace2(1, 100, 10)
+GSL::graph([x, f_log.eval(x)], [x2, f_log.eval(x2)], "-T X -C -g 3 -l x -S 4 -L 'log(x)'")

data/examples/function/min.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+humps = GSL::Function.alloc { |x|
+  1.0/(GSL::pow_2(x-0.3) + 0.01) + 1.0/(GSL::pow_2(x-0.9)+0.04) - 6
+}
+
+iter = 0;  max_iter = 500
+m = 0.7             # initial guess
+m_expected = 0.6370
+a = 0.3; b = 1.0
+gmf = GSL::Min::FMinimizer.alloc(GSL::Min::FMinimizer::BRENT)
+gmf.set(humps, 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.0001, 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.5, 1.5, 100)
+GSL::graph([x, humps.eval(x)], [GSL::Vector[m], GSL::Vector[humps.eval(m)]], "-C -g 3 -S 4 -m -1")
+
+

data/examples/function/sin.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+x = GSL::Vector.linspace(0, 2*Math::PI, 20)
+f = GSL::Function.alloc { |x|
+  GSL::Sf::sin(x)
+}
+
+f.graph(x, "-T X -g 3 -C -L 'sin(x)'")
+

data/examples/function/synchrotron.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# Find synchrotron spectrum peak
+require("gsl")
+
+# Create Function object from the module function
+F = GSL::Function.alloc { |x| GSL::Sf::synchrotron_1(x) }
+# Derivative of the function
+DF = GSL::Function.alloc { |x|  
+  result, abserr, status = F.deriv_central(x, 1e-6)  
+  result
+}
+# Find zero-point of the derivative in interval (0.01, 5)
+peak, = DF.fsolve(0.01, 5)
+printf("A peak is found at %3.2f.\n", peak)
+
+x = GSL::Vector.linspace(0, 5, 100)
+s = GSL::Sf::synchrotron_1(x)
+s.graph(x, "-C -g 3 -X x -L 'Sf::synchrotron_1(x)'")

data/examples/gallery/butterfly.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+require("gsl")
+phi = GSL::Vector.linspace(0, 12*Math::PI, 800)
+r = GSL::Sf::exp(GSL::Sf::cos(phi)) - 2*GSL::Sf::cos(4*phi) + GSL::pow_5(GSL::Sf::sin(phi/12))
+x = r*GSL::Sf::cos(phi)
+y = r*GSL::Sf::sin(phi)
+GSL::graph(x, y)

data/examples/gallery/cayley.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+a = 1
+t = GSL::Vector.linspace(0, 3*Math::PI, 100)
+cost = GSL::Sf::cos(t/3)
+cost3 = cost*cost*cost
+r = 4*a*cost3
+x = r*GSL::Sf::cos(t)
+y = r*GSL::Sf::sin(t)
+
+GSL::graph(x, y, "-T X -C")

data/examples/gallery/cornu.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+require("gsl")
+include Math
+
+sint2 = GSL::Function.alloc { |t| Math::sin(Math::PI/2*t*t) }
+cost2 = GSL::Function.alloc { |t| Math::cos(Math::PI/2*t*t) }
+w = GSL::Integration::Workspace.alloc(1000)
+
+t = 0
+STDOUT.print("Computing... ")
+STDOUT.flush
+IO.popen("graph -T X -C -g 3 -X 'C(t)' -Y 'S(t)' --toggle-rotate-y-label -L 'Cornu spiral'", "w") do |io|
+  t = -4
+  while t < 4
+    c = cost2.qag([0, t], w)[0]
+    s = sint2.qag([0, t], w)[0]
+    io.printf("%e %e\n", c, s)
+    t += 0.01
+  end
+  STDOUT.print("done\n")
+  STDOUT.flush
+  io.flush
+end

data/examples/gallery/eight.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+a = 1
+t = GSL::Vector.linspace(0, 2*Math::PI, 100)
+cost = GSL::Sf::cos(t)
+sint = GSL::Sf::sin(t)
+x = a*sint
+y = a*sint*cost
+
+GSL::graph(x, y, "-T X -C")

data/examples/gallery/koch.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+# Koch curve
+
+require("gsl")
+include Math
+
+ONE_UNIT = 3
+
+def koch(x, y, theta, size, order, file)
+  if order == 0
+    x += cos(theta)*size
+    y += sin(theta)*size
+    file.printf("%e %e\n", x, y)
+  else
+    x, y = koch(x, y, theta, size/3, order-1, file)
+    theta += Math::PI/3
+    x, y = koch(x, y, theta, size/3, order-1, file)
+    theta -= 2.0*Math::PI/3    
+    x, y = koch(x, y, theta, size/3, order-1, file)
+    theta += Math::PI/3
+    x, y = koch(x, y, theta, size/3, order-1, file)
+  end
+  return [x, y]
+end
+
+SIZE = 243
+ORDER = 4
+
+x = 0.0
+y = 0.0
+theta = 0.0
+IO.popen("graph -T X -C -N x -N y", "w") do |io|
+  io.printf("%e %e\n", x, y)
+  x, y = koch(x, y, theta, SIZE, ORDER, io)
+  theta -= 2.0*Math::PI/3
+  x, y = koch(x, y, theta, SIZE, ORDER, io)
+  theta -= 2.0*Math::PI/3
+  x, y = koch(x, y, theta, SIZE, ORDER, io)
+  theta -= 2.0*Math::PI/3
+end

data/examples/gallery/lemniscate.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+a = 1
+t = GSL::Vector.linspace(0, 2*Math::PI, 100)
+cost = GSL::Sf::cos(t)
+sint = GSL::Sf::sin(t)
+x = a*cost
+y = a*sint*cost/(1 + sint*sint)
+
+GSL::graph(x, y, "-T X -C")

data/examples/gallery/polar.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+phi = GSL::Vector.linspace(0, 2*Math::PI, 200)
+r1 = GSL::Sf::sin(4*phi)
+x1 = r1*GSL::Sf::cos(phi)
+y1 = r1*GSL::Sf::sin(phi)
+r2 = GSL::Sf::cos(4*phi)
+x2 = r2*GSL::Sf::cos(phi)
+y2 = r2*GSL::Sf::sin(phi)
+GSL::Vector.graph([x1, y1], [x2, y2])

data/examples/gallery/rgplot/cossin.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+#begin
+#  require 'rubygems'
+#  require_gem "gnuplot"         # Try using rubygem
+#ensure
+  require 'gnuplot'             # No gem, use traditional require
+#end
+
+require "gsl"
+
+# Add the to_gplot method to Vector since its not already built in.  This
+# might be worthwhile adding to the core GSL stuff.
+
+x = GSL::Vector.linspace(0, 2*M_PI, 100)
+s = Sf::sin(x)
+c = Sf::cos(x)
+
+# Now generate the actual plot
+Gnuplot::open do |gp|
+  Gnuplot::Plot.new( gp ) do |plot|
+
+    plot.title "GSL plotting example"
+    plot.data = [
+      Gnuplot::DataSet.new( [x, c] ) { |ds|
+        ds.title = "cos(x)"
+        ds.with = "lines"
+      },
+      Gnuplot::DataSet.new( [x, s] ) { |ds|
+        ds.title = "sin(x)"
+        ds.with = "lines"
+      }
+    ]
+  end
+end
+