gsl 1.12.109 → 1.14.5

data/examples/permutation/permutation.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require("gsl") 
+
+p = GSL::Permutation::alloc(10)
+p.init
+p.swap(4, 7)
+#p p.to_a
+p.print
+
+#p p.inverse.to_a
+#p p.next.to_a
+#p p.next.to_a
+#p p.next.to_a
+
+p.printf("%u \n")
+

data/examples/poly/bell.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+for n in 0..10
+  p GSL::Poly.bell(n)
+end

data/examples/poly/bessel.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+for n in 0..10
+  p GSL::Poly.bessel(n)
+end

data/examples/poly/cheb.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+for n in 0..10
+  p GSL::Poly.cheb(n)
+end

data/examples/poly/cheb_II.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+for n in 0..10
+  p GSL::Poly.cheb_II(n)
+end

data/examples/poly/cubic.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require('gsl')
+
+puts("Solve x^3 - 1 == 0")
+puts("x = 1, (-1 +/- i sqrt(3))/2")
+p GSL::Poly.complex_solve_cubic(0, 0, -1)
+
+
+__END__

data/examples/poly/demo.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+
+# Polynomial p(x) = 1.5-1.25x-3.75x^2+x^4
+poly = Poly[1.5, -1.25, -3.75, 0, 1]
+# Solve the equation p(x) == 0
+root = poly.solve    # Vector::Complex
+# Extract only the real parts 
+# (imaginary parts are zero for this case)
+re = root.real       # Vector::View
+
+puts("p(x) = 1.5-1.25x-3.75x^2+x^4 == 0")
+puts("Roots are found at #{re[0]}, #{re[1]}, #{re[2]}, #{re[3]}")
+
+# Display the result
+x = Vector.linspace(-2.5, 2.5, 20)
+y = poly.eval(x)
+zero = Vector.calloc(4)
+graph([x, y], [re, zero], "-T X -C -g 3 -S 4 -X x -L 'p(x) = 1.5-1.25x-3.75x^2+x^4'")

data/examples/poly/eval.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+# f(x) = 1 + 2x + 3x^3
+# Evaluate at x = 2 ---> f(x) = 17
+p GSL::Poly.eval([1, 2, 3], 2)
+p GSL::Poly.eval([1, 2, 3].to_gv, 2)
+p GSL::Poly.eval(NArray[1.0, 2, 3], 2)
+
+# f(1) = 6, f(2) = 17, f(3) = 34
+p GSL::Poly.eval([1, 2, 3], [1, 2, 3])
+p GSL::Poly.eval([1, 2, 3], [1, 2, 3].to_gv)
+p GSL::Poly.eval([1, 2, 3], NArray[1.0, 2, 3])
+
+
+v = GSL::Vector[1, 2, 3]
+p GSL::Poly.eval(v, [1, 2, 3])
+p GSL::Poly.eval(v, [1, 2, 3].to_gv)
+p GSL::Poly.eval(v, NArray[1.0, 2, 3])
+
+v = NArray[1.0, 2, 3]
+p GSL::Poly.eval(v, [1, 2, 3])
+p GSL::Poly.eval(v, [1, 2, 3].to_gv)
+p GSL::Poly.eval(v, NArray[1.0, 2, 3])
+
+v = GSL::Vector[1, 2, 3]
+x = GSL::Matrix.alloc(1...9, 3, 3)
+p GSL::Poly.eval(v, x)

data/examples/poly/eval_derivs.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+poly = [1, 2, 3]
+p GSL::Poly::eval_derivs(poly, 1)   # Returned Array
+
+poly = NArray[1.0, 2, 3]
+p GSL::Poly::eval_derivs(poly, 1)   # Returned NArray
+
+poly = GSL::Poly.alloc([1, 2, 3])   # Returned GSL::Poly
+p GSL::Poly::eval_derivs(poly, 1)
+
+p poly.eval_derivs(1, 3)
+

data/examples/poly/fit.rb

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

data/examples/poly/hermite.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+for n in 0..10
+  p GSL::Poly.hermite(n)
+end

data/examples/poly/poly.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require('gsl')
+
+poly = GSL::Poly.alloc(-1, 0, 0, 0, 0, 1)
+
+w = GSL::Poly::Complex::Workspace.alloc(6)
+z = poly.solve(w)
+
+for i in 0...5 do
+  printf("z%d = %+.18f %+.18f\n", i, z[i].re, z[i].im)
+end
+
+__END__

data/examples/poly/quadratic.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require('gsl')
+
+puts("Solve 2 - 3*x + x*x = 0")
+
+p GSL::Poly.solve_quadratic([1, -3, 2])
+p GSL::Poly.solve_quadratic(1, -3, 2)
+z = GSL::Poly.complex_solve_quadratic(1, -3, 2)
+printf("%f %f\n", z[0].re, z[0].im)
+printf("%f %f\n", z[1].re, z[1].im)
+#p GSL::Poly.complex_solve_quadratic([1, -3, 2])
+#z = GSL::Poly.solve([2, -3, 1])
+
+poly = GSL::Poly.alloc(2, -3, 1)
+z = poly.solve
+printf("%f %f\n", z[0].re, z[0].im)
+printf("%f %f\n", z[1].re, z[1].im)
+
+z = GSL::Poly.solve([2, -3, 1])
+printf("%f %f\n", z[0].re, z[0].im)
+printf("%f %f\n", z[1].re, z[1].im)
+
+
+
+__END__

data/examples/random/diffusion.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+# 1-dimensional random work:
+# This demonstrates M = 1000 trials of N = 6, 50 and 100 left-or-right steps.
+# The distribution of the end points of the trials
+# will be Gaussian of standard deviation sqrt(N).
+
+require("gsl")
+
+M = 1000
+GSL::Rng.env_setup()
+T = GSL::Rng::DEFAULT
+seed = 2
+rng = GSL::Rng.alloc(T, seed)
+
+h = Array.new(3)
+h[0] = GSL::Histogram.alloc(61, -30, 30)
+h[1] = GSL::Histogram.alloc(61, -30, 30)
+h[2] = GSL::Histogram.alloc(61, -30, 30)
+
+i = 0
+for n in [6, 50, 100] do
+  M.times do 
+    s = 0
+    n.times do
+      ds = rng.get%2 == 0 ? 1 : -1
+      s += ds
+    end
+    h[i].increment(s)
+  end
+  i += 1
+end
+
+#GSL::graph(h[0].shift(250), h[1].shift(100), h[2])
+GSL::graph(h[0] + 250, h[1] + 100, h[2])

data/examples/random/gaussian.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+N = 10000
+r = GSL::Rng.alloc
+v = r.gaussian(1, N)
+h = v.histogram(100, -4, 4)
+h.graph
+

data/examples/random/generator.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+
+names = ["default", "mt19937", "mt19937_1999", "mt19937_1998", "ranlxs0", "ranlxs1",
+"ranlxs2", "ranlxd1", "ranlxd2", "ranlux", "ranlux389", "cmrg", "mrg", "taus", "taus2",
+"gfsr4", "rand", "random_bsd", "random8_bsd", "random32_bsd", "random64_bsd",
+"random128_bsd", "random256_bsd", "random_libc5", "random_glibc2", "rand48", "ran0",
+"ran1", "ran2", "ran3", "ranf", "ranmar", "r250", "tt800", "vax", "transputer",
+"randu", "minstd", "uni", "uni32", "slatec", "zuf", "borosh13", "coveyou", 
+"fishman18", "fishman20", "fishman2x", "knuthran2", "knuthran", "lecuyer21", 
+"waterman14"]
+
+names.each do |name|
+  r = Rng.alloc(name)
+  printf("%s %s\n", name, r.name)
+end
+
+names.each do |name|
+  name2 = "gsl_rng_" + name
+  r = Rng.alloc(name)
+  printf("%s %s\n", name, r.name)
+end
+
+
+r = Rng.alloc(Rng::KNUTHRAN)
+p r.name

data/examples/random/hdsobol.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+
+dim = 2
+q = QRng.alloc(QRng::HDSOBOL, dim)
+#q = QRng.alloc("sobol", dim)
+#q = QRng.alloc("niederreiter_2", dim)
+#q = QRng.alloc(QRng::NIEDERREITER_2, dim)
+
+p q.name
+
+v = Vector.alloc(dim)
+IO.popen("graph -T X -C --title-font-size 0.04 -L 'Distribution of first 1024 points from the quasi-random HDSobol sequence' -m -1 -S 2", "w") do |io|
+  for i in 0..1024 do
+    #       v = q.get()    # by creating a alloc vector
+    q.get(v)       # by using an existing vector (efficient)
+    io.printf("%e %e\n", v[0], v[1])
+  end
+end
+

data/examples/random/poisson.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+N = 10000
+r = GSL::Rng.alloc
+v = r.poisson(5, N)
+h = v.histogram(20, 0, 20)
+h.graph
+

data/examples/random/qrng.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+
+dim = 2
+#q = QRng.alloc(QRng::SOBOL, dim)
+q = QRng.alloc("sobol", dim)
+#q = QRng.alloc("niederreiter_2", dim)
+#q = QRng.alloc(QRng::NIEDERREITER_2, dim)
+
+v = Vector.alloc(dim)
+IO.popen("graph -T X -C --title-font-size 0.04 -L 'Distribution of first 1024 points from the quasi-random Sobol sequence' -m -1 -S 2", "w") do |io|
+  for i in 0..1024 do
+    #       v = q.get()    # by creating a alloc vector
+    q.get(v)       # by using an existing vector (efficient)
+    io.printf("%e %e\n", v[0], v[1])
+  end
+end
+

data/examples/random/randomwalk.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+# 1-dimensional random work:
+# This demonstrates 1000 trials of 50 left-or-right steps.
+# The distribution of the end points of the trials
+# will be Gaussian of standard deviation sqrt(50).
+
+require("gsl")
+
+N = 50
+M = 1000
+GSL::Rng.env_setup()
+T = GSL::Rng::DEFAULT
+seed = 2
+rng = GSL::Rng.alloc(T, seed)
+
+sigma = Math::sqrt(N).to_i
+
+h = GSL::Histogram.alloc(8*sigma+1, [-4*sigma-0.5, 4*sigma+0.5])
+
+M.times do 
+  s = 0
+  N.times do
+    ds = rng.get%2 == 0 ? 1 : -1
+    s += ds
+  end
+  h.increment(s)
+end
+
+x = GSL::Vector.linspace(-40, 40, 80)
+y = GSL::Ran::gaussian_pdf(x, sigma)*M*2  
+# Factor 2 is not important, but necessary 
+# because only the even ranges are filled:
+#   a + b = N     a: positive steps, b: negative steps
+#   a - b = s     s: the end point after the N steps
+# Since N = 1000 and a, b, s are integer, s must be even.
+GSL::graph(h, [x, y], "-C -x #{-4*sigma} #{4*sigma}")
+

data/examples/random/randomwalk2d.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+N = 1000
+GSL::Rng.env_setup()
+T = GSL::Rng::DEFAULT
+r = GSL::Rng.alloc(T)
+
+x = 0.0
+y = 0.0
+
+printf("%g %g\n", x, y);
+
+N.times do
+  dx, dy = r.dir_2d()
+  x += dx
+  y += dy
+  printf("%g %g\n", x, y);
+end

data/examples/random/rayleigh.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+require("gsl")
+rng = GSL::Rng.alloc()
+
+N = 100
+XMAX = 5.0
+sigma = 1.0
+h = GSL::Histogram.alloc(N, 0, XMAX)
+for i in 0...10000 do
+  x = rng.rayleigh(sigma)
+  h.increment(x)
+end
+
+sig, amp = h.fit_rayleigh
+p sig
+p amp
+
+v = GSL::Vector.linspace(0, XMAX, N)
+val = GSL::Ran::rayleigh_pdf(v, sig)
+val *= amp
+GSL::graph(h, [v, val], "-T X -C")
+
+h2 = GSL::Histogram.alloc(N, 0, XMAX)
+for i in 0...10000 do
+  x = rng.gaussian(sigma)
+  y = rng.gaussian(sigma)
+  r = Math.sqrt(x*x + y*y)
+  h2.increment(r)
+end
+sig2, amp2 = h2.fit_rayleigh
+p sig2
+p amp2
+val2 = GSL::Ran::rayleigh_pdf(v, sig2)
+val2 *= amp2
+GSL::graph(h2, [v, val2], "-T X -C")
+

data/examples/random/rng.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+r = GSL::Rng.alloc
+10.times {
+  p r.uniform
+}
+
+__END__
+#include GSL
+#require 'gsl/gsl_rng'
+
+r = GSL::Random::Rng.alloc
+r.set(2)
+p r.get
+p r.get
+p r.max
+p r.get
+p r.get
+
+r2 = GSL::Random::Rng.alloc 
+p r2.uniform
+p r2.uniform
+
+__END__
+rf = GSL::Random::Rng.alloc
+p rf.uniform
+p rf.uniform
+
+p rf.name
+
+
+p gsl_rng_types_setup