rb-gsl 1.15.3.1

data/examples/sf/hyperg.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+require("gsl") 
+
+p GSL::Sf.hyperg_0F1(2, 3)
+r = GSL::Sf.hyperg_0F1_e(2, 3)
+p r.val
+

data/examples/sf/laguerre.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+require("gsl")
+x = GSL::Vector.linspace(0, 5, 40)
+e = GSL::Sf::exp(-x/2)
+
+a = 0
+IO.popen("graph -T X -C -g 3 -L 'Laguerre functions'", "w") do |io|
+  for n in 0..5 do
+    for i in 0...20 do
+      y = GSL::Sf::laguerre_n(n, a, x[i])*e[i]
+      io.printf("%e %e\n", x[i], y)
+    end
+    io.printf("\n")
+  end
+end
+
+
+
+

data/examples/sf/lambertW.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require("gsl")
+n = 50
+x = GSL::Vector.linspace(-0.35, 10, n)
+GSL::Sf::lambert_W0(x).graph(x, "-T X -C -g 3 -X x -L 'Lambert W function'")

data/examples/sf/legendre_P.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+require("gsl")
+n = 50
+x = GSL::Vector.linspace(-1, 1, n)
+y1 = GSL::Sf::legendre_P1(x)
+y2 = GSL::Sf::legendre_P2(x)
+y3 = GSL::Sf::legendre_P3(x)
+y4 = GSL::Sf::legendre_Pl(4, x)
+y5 = GSL::Sf::legendre_Pl(5, x)
+GSL::Vector.graph(x, y1, y2, y3, y4, y5, "-T X -C -g 3 -X x -Y 'P(x)' --toggle-rotate-y-label -L 'Legendre P functions'")

data/examples/sf/lngamma.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require("gsl")
+x = GSL::Vector.linspace(0.01, 14, 50)
+y = GSL::Sf::lngamma(x)
+GSL::graph(x, y, "-T X -C -g 3 -l y -L 'lngamma(x)'")

data/examples/sf/psi.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+require("gsl")
+IO.popen("graph -T X -C -g 3 -X x -Y 'psi(x)' --toggle-rotate-y-label -x -3 5 -y -5 15 -L 'Red: Digamma, Green: Trigamma'", "w") do |io|
+  x = -2.999
+  while x < -2
+    y = GSL::Sf::psi(x)
+    io.printf("%e %e\n", x, y)
+    x += 0.01
+  end
+  x = -1.999
+  while x < -1
+    y = GSL::Sf::psi(x)
+    io.printf("%e %e\n", x, y)
+    x += 0.01
+  end
+  x = -0.999
+  while x < 0
+    y = GSL::Sf::psi(x)
+    io.printf("%e %e\n", x, y)
+    x += 0.01
+  end
+  x = 0.001
+  while x < 5
+    y = GSL::Sf::psi(x)
+    io.printf("%e %e\n", x, y)
+    x += 0.1
+  end
+
+  io.printf("\n")
+  x = -2.999
+  while x < -2
+    y = GSL::Sf::psi_1_e(x).val
+    io.printf("%e %e\n", x, y)
+    x += 0.01
+  end
+  x = -1.999
+  while x < -1
+    y = GSL::Sf::psi_1_e(x).val
+    io.printf("%e %e\n", x, y)
+    x += 0.01
+  end
+  x = -0.999
+  while x < 0
+    y = GSL::Sf::psi_1_e(x).val
+    io.printf("%e %e\n", x, y)
+    x += 0.01
+  end
+  x = 0.001
+  while x < 5
+    y = GSL::Sf::psi_1_e(x).val
+    io.printf("%e %e\n", x, y)
+    x += 0.1
+  end
+end

data/examples/sf/sphbessel.gp

@@ -0,0 +1,27 @@
+set multiplot
+set size 0.5, 0.5
+set xrange [0:12]
+set grid
+set xlabel 'x'
+
+set origin 0, 0.5
+set yrange [-0.5:1.2]
+set ylabel 'j(x)'
+plot 'sphbessel.dat' u 1:2 title 'j0' w l lw 2, '' u 1:3 title 'j1' w l lw 2, '' u 1:4 title 'j2' w l lw 2, '' u 1:5 title 'j3' w l lw 2
+
+set origin 0.5, 0.5
+set ylabel 'y(x)'
+set yrange [-1:0.6]
+plot 'sphbessel.dat' u 1:6 title 'y0' w l lw 2, '' u 1:7 title 'y1' w l lw 2, '' u 1:8 title 'y2' w l lw 2
+
+set xrange [0:4]
+set yrange [0:1]
+set origin 0, 0
+set ylabel 'exp(-|x|) i(x)'
+plot 'sphbessel.dat' u 1:9 title 'i0' w l lw 2, '' u 1:10 title 'i1' w l lw 2, '' u 1:11 title 'i2' w l lw 2
+
+set origin 0.5, 0
+set yrange [0:10]
+set ylabel 'exp(x) k(x)'
+plot 'sphbessel.dat' u 1:12 title 'k0' w l lw 2, '' u 1:13 title 'k1' w l lw 2, '' u 1:14 title 'k2' w l lw 2
+

data/examples/sf/sphbessel.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL::Sf
+
+l = 2
+x = 0.01
+File.open("sphbessel.dat", "w") do |file|
+  while x <= 12.0
+    j0 = bessel_j0(x)
+    j1 = bessel_j1(x)
+    j2 = bessel_jl(2, x)
+    j3 = bessel_jl(3,x)
+    y0 = bessel_y0(x)
+    y1 = bessel_y1(x)
+    y2 = bessel_y2(x)
+    i0 = bessel_i0_scaled(x)
+    i1 = bessel_i1_scaled(x)
+    i2 = bessel_i2_scaled(x)
+    k0 = bessel_k0_scaled(x)
+    k1 = bessel_k1_scaled(x)
+    k2 = bessel_k2_scaled(x)
+    file.printf("%e %e %e %e %e %e %e %e %e %e %e %e %e %e\n", 
+                x, j0, j1, j2, j3, y0, y1, y2, i0, i1, i2, k0, k1, k2)
+    x += 0.1
+  end
+end
+
+#puts("sphbessel.dat created. Try sphbessel.gp.")
+system("gnuplot -persist sphbessel.gp")
+File.delete("sphbessel.dat")

data/examples/sf/synchrotron.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require("gsl")
+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/sf/transport.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+require("gsl")
+n = 50
+x = GSL::Vector.linspace(0, 2, n)
+
+y2 = GSL::Sf::transport_2(x)
+y3 = GSL::Sf::transport_3(x)
+y4 = GSL::Sf::transport_4(x)
+y5 = GSL::Sf::transport_5(x)
+GSL::Vector.graph(x, y2, y3, y4, y5, "-T X -C -g 3 -X x -Y 'J(x)' --toggle-rotate-y-label -L 'Transport functions'")

data/examples/sf/zetam1.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require("gsl")
+s = GSL::Vector.linspace(1.05, 13, 100)
+y = GSL::Sf::zetam1(s)
+y.graph(s, "-C -l y -L 'Zeta function z(s)-1' -X s -Y 'z(s)-1' --toggle-rotate-y-label")

data/examples/siman.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+include GSL::Siman
+
+N_TRIES = 200
+ITERS_FIXED_T = 10
+STEP_SIZE = 10
+K = 1.0
+T_INITIAL = 0.002
+MU_T = 1.005
+T_MIN = 2.0e-6
+
+params = Siman::Params.alloc(N_TRIES, ITERS_FIXED_T, STEP_SIZE, K, T_INITIAL,
+                           MU_T, T_MIN)
+
+efunc = Efunc.alloc { |vx|
+  x = vx[0]
+  s = (x - 1.0)
+  Math::exp(-s*s)*Math::sin(8*x)
+}
+
+metric = Metric.alloc { |vx, vy|
+  (x[0] - y[0]).abs
+}
+
+step = Step.alloc { |rng, vx, step_size|
+  r = rng.uniform
+  old_x = vx[0]
+  a =  r * 2 * step_size - step_size + old_x
+  vx[0] = a
+}
+
+simanprint = Print.alloc { |vx|
+  printf("%12g", vx[0])
+}
+
+x = GSL::Vector.alloc([15.5])
+GSL::Rng.env_setup()
+r = GSL::Rng.alloc()
+
+Siman::solve(r, x, efunc, step, metric, simanprint, params)
+#Siman::solve(r, x, efunc, step, metric, nil, params)
+p x

data/examples/sort/heapsort.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+v = GSL::Vector.alloc(1, 2, 6, 7, 8, 9, 3, 4, 5)
+
+p v.heapsort { |a, b|
+  b <=> a
+}
+p v
+
+p v.heapsort! { |a, b|
+  b <=> a
+}
+p v
+
+v = GSL::Vector.alloc(1, 2, 6, 7, 8, 9, 3, 4, 5)
+p v.heapsort_index { |a, b|
+  a <=> b
+}
+
+p GSL.heapsort(v) { |a, b|
+  b <=> a
+}

data/examples/sort/heapsort_vector_complex.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+v = GSL::Vector::Complex.alloc(5)
+v[0] = [1, 2]
+v[1] = [3, 4]
+v[2] = [0, 1]
+v[3] = [15, 3]
+v[4] = [5, 7]
+
+p v.heapsort { |a, b|
+  a.abs <=> b.abs
+}
+
+p v.heapsort { |a, b|
+  b.abs <=> a.abs
+}
+
+p GSL.heapsort(v) { |a, b|
+  b.abs <=> a.abs
+}

data/examples/sort/sort.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+require("gsl") 
+
+N = 100000
+k = 5
+
+x = GSL::Vector.alloc(N)
+
+GSL::Rng.env_setup()
+T = GSL::Rng::DEFAULT
+r = GSL::Rng.alloc(T)
+
+for i in 0...N do
+  x[i] = r.uniform()
+end
+
+small = x.sort_smallest(k)
+
+printf("%d smallest values from %d\n", k, N);
+
+for i in 0...k do
+  printf("%d: %.18f\n", i, small[i]);
+end

data/examples/sort/sort2.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+v = GSL::Vector.alloc(1, 2, 6, 7, 8, 9, 3, 4, 5)
+p v.smallest(5)
+p v.largest(3)
+
+p v.smallest_index(3)
+p v.largest_index(5)
+
+p v.sort
+p v
+
+v.sort!
+p v
+

data/examples/stats/mean.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+N = 100000
+rng = GSL::Rng.alloc
+
+v = rng.gaussian(2, N)
+
+p v.mean
+p v.variance
+p v.sd
+
+p v.variance_m(0)
+p v.sd_m(0)
+
+p v.variance_with_fixed_mean(0)
+p v.sd_with_fixed_mean(0)

data/examples/stats/statistics.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+data =  GSL::Vector[17.2, 18.1, 16.5, 18.3, 12.6]
+mean     = data.mean()
+variance = data.variance()
+largest  = data.max()
+smallest = data.min()
+
+printf("The dataset is %g, %g, %g, %g, %g\n",
+        data[0], data[1], data[2], data[3], data[4]);
+
+printf("The sample mean is %g\n", mean);
+printf("The estimated variance is %g\n", variance);
+printf("The largest value is %g\n", largest);
+printf("The smallest value is %g\n", smallest);
+
+p data.stats_sd

data/examples/stats/test.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+v = GSL::Vector.alloc([17.2, 18.1, 16.5, 18.3, 12.6])
+p GSL::Stats.mean(v)
+p GSL::Stats.variance(v)
+p GSL::Stats.sd(v)
+p GSL::Stats.max(v)
+p GSL::Stats.min(v)

data/examples/sum.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+require("gsl")
+include Math
+
+N = 20
+Zeta2 = PI*PI/6.0
+
+v = GSL::Vector.alloc(N)
+sum = 0.0
+for n in 0...N do
+  np1 = n.to_f + 1.0
+  v[n] = 1.0/(np1 * np1)
+  sum += v[n]
+end
+
+#sum_accel, err, sum_plain, terms_used = v.accel_sum
+#sum_accel, err, sum_plain, terms_used = v.sum_accel
+sum_accel, err, sum_plain, terms_used = v.accel
+
+printf("term-by-term sum = %.16f using %d terms\n", sum, N)
+printf("term-by-term sum = %.16f using %d terms\n", sum_plain, terms_used)
+printf("exact value      = %.16f\n", Zeta2)
+printf("accelerated sum  = %.16f using %d terms\n", sum_accel, terms_used)
+printf("Estimated error  = %.16f\n", err)
+printf("Actual error     = %.16f\n", sum_accel - Zeta2)
+
+p GSL::Sum::Levin_u.accel(v)
+p GSL::Sum::Levin_utrunc.accel(v)
+
+lu = GSL::Sum::Levin_u.alloc(N)
+p lu.accel(v)
+
+lutrunc = GSL::Sum::Levin_utrunc.alloc(N)
+p lutrunc.accel(v)

data/examples/tamu_anova.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+data = GSL::Vector[88.60,73.20,91.40,68.00,75.20,63.00,53.90,69.20, 
+50.10,71.50,44.90,59.50,40.20,56.30,38.70,31.00, 
+39.60,45.30,25.20,22.70]
+factor = GSL::Vector::Int[1,1,1,1,1,2,2,2,2,2,3,3,3,3,3,4,4,4,4,4]
+
+table = GSL::TAMU_ANOVA::Table.oneway(data, factor, 4)
+table.print
+
+data = GSL::Vector[45.50,45.30,45.40,44.40,44.60,43.90,44.60,44.00,44.20, 
+43.90,44.70,44.20,44.00,43.80,44.60,43.10,46.00,45.90, 
+44.80,46.20,45.10,45.50]
+factor = GSL::Vector::Int[1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,3,3,3,3,3,3]
+
+table = GSL::TAMU_ANOVA::Table.oneway(data, factor, 3)
+table.print

data/examples/vector/add.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+# Turn on warnings
+$-w = true
+
+require 'irb/xmp'
+require 'gsl'
+
+# Apparently, IRB::Frame has a bug that prevents the defaults from working, so
+# an XMP instance must be created explicitly this way instead of using the
+# otherwise convenient xmp method.
+XMP.new(IRB::Frame.top(-1)).puts <<END
+# Create two Vectors
+a = GSL::Vector.alloc(1, 2, 3, 4, 5)
+b = GSL::Vector.alloc(6, 7, 8, 9, 10)
+
+# Show the sum of a and b
+a + b
+
+# Add b to a
+a += b
+
+# Show a
+a
+
+# Subtract b from a
+a -= b 
+
+# Show a
+a
+
+# Create new Vector containing 2 added to all elements of a
+a + 2
+
+# Show that a remains unmodified
+a
+
+# Add 2 to all elements of a in-place
+a += 2
+
+# Show the modified a
+a
+
+# Subtract 2 from all elements of a in-place
+a -= 2
+
+# Show that a remains unmodified
+a
+
+# Show coersion
+2 + a
+
+5 - a
+
+# Show that a remains unmodified
+a
+END