rb-gsl 1.15.3.1

data/examples/gallery/rgplot/roesller.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+require("gnuplot")
+require("gsl")
+
+dim = 3
+roesller = Proc.new { |t, v, dvdt, params|
+  a = params[0]; b = params[1]; c = params[2]
+  x = v[0]; y = v[1]; z = v[2]
+  dvdt[0] = - y - z
+  dvdt[1] = x + a*y
+  dvdt[2] = b*x - (c - x)*z
+}
+
+a = 0.344
+b = 0.4
+c = 4.5
+solver = GSL::Odeiv::Solver.new(GSL::Odeiv::Step::RKF45, [1e-6, 0.0], roesller, dim)
+solver.set_params(a, b, c)
+
+t = 0.0; tend = 100.0
+h = 1e-6
+v = GSL::Vector[1, 0, 0]
+
+GSL::ieee_env_setup()
+
+N = 1000
+x = GSL::Vector[N]
+y = GSL::Vector[N]
+z = GSL::Vector[N]
+
+i = 0
+while t < tend
+  t, h, status = solver.apply(t, tend, h, v)
+  x[i] = v[0]
+  y[i] = v[1]
+  z[i] = v[2]
+  i += 1
+  break if status != GSL::SUCCESS
+end
+
+Gnuplot::open do |gp|
+  Gnuplot::SPlot.new( gp ) do |plot|
+
+    plot.title "Roesller equation"
+
+    plot.data = [
+      Gnuplot::DataSet.new( [x.subvector(i), y.subvector(i), z.subvector(i)] ) { |ds|
+        ds.title = ""
+        ds.with = "lines"
+      }
+    ]
+  end
+end
+
+

data/examples/gallery/roesller.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+dim = 3
+roesller = Proc.new { |t, v, dvdt, params|
+  a = params[0]; b = params[1]; c = params[2]
+  x = v[0]; y = v[1]; z = v[2]
+  dvdt[0] = - y - z
+  dvdt[1] = x + a*y
+  dvdt[2] = b*x - (c - x)*z
+}
+
+a = 0.344
+b = 0.4
+c = 4.5
+solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RKF45, [1e-6, 0.0], roesller, dim)
+solver.set_params(a, b, c)
+
+t = 0.0; tend = 100.0
+h = 1e-6
+v = GSL::Vector.alloc(1, 0, 0)
+
+GSL::ieee_env_setup()
+
+IO.popen("gnuplot -persist", "w") do |io|
+  io.print("set title 'Roesller equation'\n")
+  io.print("set xlabel 'X'\n")
+  io.print("set ylabel 'Y'\n")
+  io.print("set zlabel 'Z'\n")
+  io.printf("splot '-' u 2:3:4 w l\n")
+  while t < tend
+    t, h, status = solver.apply(t, tend, h, v)
+    io.printf("%e %e %e %e\n", t, v[0], v[1], v[2])
+    break if status != GSL::SUCCESS
+  end
+  io.printf("e\n")
+  io.flush
+end
+

data/examples/gallery/scarabaeus.rb

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

data/examples/histogram/cauchy.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# Usage from command line:
+#  % gsl-randist 0 10000 cauchy 30 | ./hist1d.rb -100 100 200 
+
+require("gsl")
+
+if ARGV.size != 3
+  puts("Usage: gsl-histogram xmin xmax n")
+  puts("  Computes a histogram of the data")
+  puts("  on stdin using n bins from xmin to xmax")
+end
+
+a = ARGV.shift.to_f
+b = ARGV.shift.to_f
+n = ARGV.shift.to_i
+
+h = GSL::Histogram.alloc(n, a, b)
+
+while line = STDIN.gets
+  x = line.chomp.to_f
+  h.increment(x)
+end
+
+h.graph("-C -g 3 -L 'gsl-randist 0 10000 cauchy 30'")
+
+
+ 

data/examples/histogram/cauchy.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+gsl-randist 0 10000 cauchy 30 | ruby cauchy.rb -100 100 200

data/examples/histogram/exponential.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+N = 10000
+rng = GSL::Rng.alloc
+data = rng.exponential(2, N)
+h = GSL::Histogram.alloc(100, [0, 15])
+h.fill(data)
+
+#result = h.fit_exponential
+result = h.fit("exponential")
+a = result[0]
+b = result[1]
+
+x = GSL::Vector.linspace(0, 15, 100)
+y = a*GSL::Sf::exp(x*b)
+GSL::graph(h, [x, y], "-C -g 3")
+
+  

data/examples/histogram/gauss.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+N = 10000
+MAX = 8
+rng = GSL::Rng.alloc(2)
+
+data = GSL::Ran.gaussian(rng, 1.5, N) + 2
+h = GSL::Histogram.alloc(100, [-MAX, MAX])
+h.increment(data)
+
+sigma, mean, height, = h.fit_gaussian
+
+x = GSL::Vector.linspace(-MAX, MAX, 100)
+y = height*GSL::Ran::gaussian_pdf(x-mean, sigma)
+GSL::graph(h, [x, y], "-T X -C -g 3")

data/examples/histogram/gsl-histogram.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+# This is equivalent to the gsl-histogram program
+
+require("gsl")
+require("getopts")
+
+getopts(nil, "DISPLAY_STATS")
+
+case ARGV.size
+when 2
+  a = ARGV[0].to_f
+  b = ARGV[1].to_f
+  n = (b - a).to_i
+when 3
+  a = ARGV[0].to_f
+  b = ARGV[1].to_f
+  n = ARGV[2].to_i
+else
+  puts("Usage: : gsl-histogram.rb [--DISPLAY_STATS] xmin xmax [n]")
+  puts("Computes a histogram of the data on stdin using n bins from xmin to xmax.")
+  puts("If n is unspecified then bins of integer width are used.")
+  exit
+end
+
+h = GSL::Histogram.alloc(n)
+h.set_ranges_uniform(a, b)
+
+while line = STDIN.gets
+  x = line.chomp.split[0].to_f
+  h.increment(x)
+end
+
+if $OPT_DISPLAY_STATS
+  printf("# mean = %g\n", h.mean)
+  printf("# sigma = %g\n", h.sigma)
+end
+
+h.fprintf(STDOUT, "%g", "%g")
+
+exit

data/examples/histogram/histo2d.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+require("gsl")
+N = 10000
+BINS = 100
+
+rng = GSL::Rng.alloc("mt19937", 123456)
+
+h2 = GSL::Histogram2d.alloc(BINS, [-8, 8], BINS, [-8, 8])
+
+sig1 = 0.8
+sig2 = 2.0
+
+for i in 0...N do
+  r1 = rng.gaussian(sig1) + 2.5
+  r2 = rng.gaussian(sig2) - 1
+  h2.increment(r1, r2)
+end
+
+hx = h2.xproject
+hy = h2.yproject
+printf("%f %f %f %f\n", h2.xmean, h2.ymean, hx.mean, hy.mean)
+printf("%f %f %f %f\n", h2.xsigma, h2.ysigma, hx.sigma, hy.sigma)
+
+x = GSL::Vector.linspace(-8, 8, 100)
+result = hx.fit_gaussian
+y1 = result[2]*GSL::Ran::gaussian_pdf(x-result[1], result[0])
+result = hy.fit_gaussian
+y2 = result[2]*GSL::Ran::gaussian_pdf(x-result[1], result[0])
+GSL::graph(hx, hy, [x, y1], [x, y2], "-T X -C -g 3")
+
+

data/examples/histogram/histo3d.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+N = 5000
+BINS = 50
+rng = GSL::Rng.alloc(1)
+
+h = GSL::Histogram3d.alloc(BINS, [-5, 5], BINS, [-4, 8], BINS, [-8, 3]) 
+sig1 = 1
+sig2 = 2
+sig3 = 1.3
+
+for i in 0...N do
+  r1 = rng.gaussian(sig1) + 1
+  r2 = rng.gaussian(sig2) + 1.5
+  r3 = rng.gaussian(sig3) - 2
+  h.increment(r1, r2, r3)
+end
+
+hxy = h.xyproject
+h1 = hxy.xproject
+h2 = hxy.yproject
+hxz = h.xzproject
+h3 = hxz.yproject
+
+x = GSL::Vector.linspace(-7, 7, 100)
+a = h1.fit_gaussian   # a[0]: sigma, a[1]: mean, a[2]: height
+y1 = a[2]*GSL::Ran::gaussian_pdf(x-a[1], a[0])
+a = h2.fit_gaussian   # a[0]: sigma, a[1]: mean, a[2]: height
+y2 = a[2]*GSL::Ran::gaussian_pdf(x-a[1], a[0])
+a = h3.fit_gaussian   # a[0]: sigma, a[1]: mean, a[2]: height
+y3 = a[2]*GSL::Ran::gaussian_pdf(x-a[1], a[0])
+
+GSL::graph(h1, h2, h3, [x, y1], [x, y2], [x, y3])

data/examples/histogram/histogram-pdf.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+NDATA = 1000
+NBINS = 100
+MAX = 8
+
+rng = GSL::Rng.alloc()
+data = GSL::Ran.gaussian(rng, 1.0, NDATA) + 2
+h = GSL::Histogram.alloc(NBINS, [-MAX, MAX])
+h.fill(data)
+
+hpdf = GSL::Histogram::Pdf.alloc(h)
+
+rng2 = GSL::Rng.alloc()
+h2 = GSL::Histogram.alloc(NBINS, [-MAX, MAX])
+NDATA2 = 10000
+for i in 0...NDATA2 do
+	val = hpdf.sample(rng2.uniform())
+	h2.fill(val)
+end
+
+GSL::graph(h, h2)
+
+sum = h.sum()      # NDATA
+sum2 = h2.sum()    # NDATA2
+GSL::graph(h, h2.scale(sum/sum2))

data/examples/histogram/histogram.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+h = GSL::Histogram.alloc(5)
+p h
+p h.size
+
+h.set_ranges([1, 5, 23, 45, 67, 89])
+p h.range
+
+h.set_ranges_uniform(0.0, 100)
+p h.range
+p h.get_range(3)
+p h.max
+p h.bins
+p h.find(55)
+
+#File.open("smp.dat") do |f|
+#  h.fscanf(f)
+#end
+
+h.fscanf("smp.dat")
+
+p h.max_val
+p h.max_bin
+

data/examples/histogram/integral.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+N = 10000
+BINS = 100
+
+rng1 = GSL::Rng.alloc(2)
+
+h = GSL::Histogram.alloc(BINS, [-5, 5])
+
+for i in 0...N do
+  r1 = rng1.gaussian
+  h.increment(r1)
+end
+
+# Integrate: cumulative distribution
+hi = h.integrate
+
+a = hi.diff
+
+# Scale the histograms to ~ 1 at the maximum (to display together)
+h.scale!(1.0/h[BINS/2])
+a.scale!(1.0/a[BINS/2])
+
+hi.normalize!                  # this is equivalent to hi.scale(1.0/hi[BINS-1])
+
+GSL::graph(h, hi,a,  "-T X -C -g 3")
+

data/examples/histogram/poisson.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+require("gsl")
+GSL::Rng.env_setup()
+
+N = 10000
+rng = GSL::Rng.alloc
+
+h = GSL::Histogram.alloc(20, [0, 20])
+
+=begin
+for i in 0...N do
+  r = rng.poisson(5)
+#  r = GSL::Ran::poisson(rng, 5)
+  h.increment(r)
+end
+=end
+
+v = rng.poisson(5, N)
+h.fill(v)
+
+h.normalize!
+x = GSL::Vector.linspace(0, 20, 100)
+y = GSL::Ran::poisson_pdf(x, 5)
+GSL::graph(h, [x, y], "-C -g 3 -L 'Poisson distribution, mu = 5'")
+
+
+

data/examples/histogram/power.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require("gsl")
+include Math
+
+def ran_power_law(slope, range, rng)
+  x = rng.uniform
+  xmin = GSL::pow(10.0, range*(1.0 + slope));
+  x2 = (1 - xmin)*x + xmin;
+  return GSL::pow(x2, 1.0/(1+slope));
+end
+
+h = GSL::Histogram.alloc(19, [1, 20])
+rng = GSL::Rng.alloc
+for i in 0..5000
+  x = ran_power_law(-3.2, 1000, rng)
+  h.increment(x)
+end
+
+result = h.fit_power
+x = GSL::Vector.logspace2(1, 20, 19)
+y = result[0]*GSL::pow(x, result[1])
+GSL::graph(h, [x, y], "-l x -l y -x 1 20 -y 1 10000 -C -g 3")
+
+puts("Expected power index: -3.2")
+printf("Estimated power index: %5.4f +/- %5.4f\n", result[1], result[3])

data/examples/histogram/rebin.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+h = GSL::Histogram.alloc(100, [-4, 4])
+
+rng = GSL::Rng.alloc
+for i in 0..10000 do
+  h.increment(rng.gaussian)
+end
+
+h2 = h.rebin
+h5 = h.rebin(5)
+h7 = h.rebin(7)
+
+printf("%d %d %d %d\n", h.n, h2.n, h5.n, h7.n)
+printf("%f %f %f %f\n", h.sigma, h2.sigma, h5.sigma, h7.sigma)
+GSL::graph(h, h2, h5, h7, "-T X -C -g 3 -x -4 4")