rb-gsl 1.15.3.1

data/tests/cheb.rb

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+# Ruby/GSL implementation of GSL "cheb/test.c"
+require("gsl")
+require("./gsl_test.rb")
+include GSL::Test
+include Math
+
+f_T0 = GSL::Function.alloc { |x| 1.0 }
+f_T1 = GSL::Function.alloc { |x| x }
+f_T2 = GSL::Function.alloc { |x| 2.0*x*x - 1.0 }
+f_sin = GSL::Function.alloc { |x| sin(x) }
+
+tol = 100.0*GSL::DBL_EPSILON
+
+order = 40
+
+cs = GSL::Cheb.alloc(order)
+csd = GSL::Cheb.alloc(order)
+csi = GSL::Cheb.alloc(order)
+
+GSL::ieee_env_setup()
+
+cs.init(f_T0, -1.0, 1.0)
+for i in 0...order do
+  c_exp = i == 0 ? 2.0 : 0.0
+  desc = sprintf("c[%d] for T_0(x)", i)
+  GSL::Test.test_abs(cs.c[i], c_exp, tol, desc)
+end
+
+cs.init(f_T1, -1.0, 1.0)
+for i in 0...order do
+  c_exp = i == 1 ? 1.0 : 0.0
+  desc = sprintf("c[%d] for T_1(x)", i)
+  GSL::Test.test_abs(cs.c[i], c_exp, tol, desc)
+end
+
+cs.init(f_T2, -1.0, 1.0)
+for i in 0...order do
+  c_exp = i == 2 ? 1.0 : 0.0
+  desc = sprintf("c[%d] for T_2(x)", i)
+  GSL::Test.test_abs(cs.c[i], c_exp, tol, desc)
+end
+
+cs.init(f_sin, -M_PI, M_PI)
+GSL::Test.test_abs(cs.c[0], 0.0, tol, "c[0] for F_sin(x)")
+GSL::Test.test_abs(cs.c[1], 5.69230686359506e-01, tol, "c[1] for F_sin(x)")
+GSL::Test.test_abs(cs.c[2], 0.0, tol, "c[2] for F_sin(x)")
+GSL::Test.test_abs(cs.c[3], -6.66916672405979e-01, tol, "c[3] for F_sin(x)")
+GSL::Test.test_abs(cs.c[4], 0.0, tol, "c[4] for F_sin(x)")
+GSL::Test.test_abs(cs.c[5], 1.04282368734237e-01, tol, "c[5] for F_sin(x)")
+
+x = -M_PI
+while x < M_PI
+  r = cs.eval(x)
+  desc = sprintf("GSL::Cheb#eval, sin\(%.3g\)", x)
+  GSL::Test.test_abs(r, sin(x), tol, desc)
+  x += M_PI/100.0
+end
+
+x = -M_PI
+while x < M_PI
+  r, e = cs.eval_err(x)
+  desc = sprintf("GSL::Cheb#eval_err, sin\(%.3g\)", x)
+  GSL::Test.test_abs(r, sin(x), tol, desc)
+  desc = sprintf("GSL::Cheb#eval_err, error sin\(%.3g\)", x)
+  GSL::Test.test_factor((r-sin(x)).abs + GSL::DBL_EPSILON, e, 10.0, desc)
+  x += M_PI/100.0
+end
+
+x = -M_PI
+while x < M_PI
+  r = cs.eval_n(25, x)
+  desc = sprintf("GSL::Cheb#eval_n, sin\(%.3g\)", x)
+  GSL::Test.test_abs(r, sin(x), tol, desc)
+  x += M_PI/100.0
+end
+
+x = -M_PI
+while x < M_PI
+  r, e = cs.eval_n_err(25, x)
+  desc = sprintf("GSL::Cheb#eval_n_err, sin\(%.3g\)", x)
+  GSL::Test.test_abs(r, sin(x), tol, desc)
+  desc = sprintf("GSL::Cheb#eval_n_err, error sin\(%.3g\)", x)
+  GSL::Test.test_factor((r-sin(x)).abs + GSL::DBL_EPSILON, e, 10.0, desc)
+  x += M_PI/100.0
+end
+
+csd = cs.calc_deriv
+#cs.calc_deriv(csd)
+#csd = GSL::Cheb.calc_deriv(cs)
+#GSL::Cheb.calc_deriv(csd, cs)
+x = -M_PI
+while x < M_PI
+  r = csd.eval(x)
+  desc = sprintf("GSL::Cheb#eval, deriv sin\(%.3g\)", x)
+  GSL::Test.test_abs(r, cos(x), 1600*tol, desc)
+  x += M_PI/100.0
+end
+
+csi = cs.calc_integ
+#cs.calc_integ(csi)
+#csi = GSL::Cheb.calc_integ(cs)
+#GSL::Cheb.calc_integ(csi, cs)
+x = -M_PI
+while x < M_PI
+  r = csi.eval(x)
+  desc = sprintf("GSL::Cheb#eval, integ sin\(%.3g\)", x)
+  GSL::Test.test_abs(r, -(1+cos(x)), tol, desc)
+  x += M_PI/100.0
+end
+
+

data/tests/combination.rb

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+# Ruby/GSL implementation of GSL "combination/test.c"
+require("gsl")
+require("./gsl_test.rb")
+include GSL::Test
+
+c63 = GSL::Matrix.alloc([0, 1, 2], [0, 1, 3], [0, 1, 4], [0, 1, 5], 
+                 [0, 2, 3], [0, 2, 4], [0, 2, 5], 
+                 [0, 3, 4], [0, 3, 5],
+                 [0, 4, 5], 
+                 [1, 2, 3], [1, 2, 4], [1, 2, 5],
+                 [1, 3, 4], [1, 3, 5],
+                 [1, 4, 5],
+                 [2, 3, 4], [2, 3, 5], [2, 4, 5],
+                 [3, 4, 5])
+
+GSL::IEEE.env_setup()
+
+status = false
+c = GSL::Combination.alloc(6, 3)
+c.init_first
+
+i = 0
+begin
+  if i >= 20
+    status = true
+    break
+  end
+  for j in 0...3
+    status |= (c.data[j] != c63[i,j])
+  end
+
+  s1 = c.valid?
+  desc = sprintf("GSL::Combination#valid\(%u\)", i)
+  GSL::Test.test(s1, desc)
+  i += 1
+end while c.next == GSL::SUCCESS
+
+GSL::Test.test(status, "GSL::Combination#next, 6 choose 3 combination, 20 steps")
+
+c.next
+c.next
+c.next
+
+for j in 0...3 
+  status |= (c.data[j] != c63[19,j])
+end
+GSL::Test.test(status, "GSL::Combination#next on the last combination")
+
+s1 = c.valid?
+GSL::Test.test(s1, "GSL::Combination#valid on the last combination")
+
+d = GSL::Combination.alloc(6, 3)
+GSL::Combination.memcpy(d, c)
+
+status = false
+for j in 0...3 
+  status |= (d.data[j] != c.data[j])
+end
+GSL::Test.test(status, "GSL::Combination.memcpy, 6 choose 3 combination")
+
+c.init_last
+i = 20
+begin
+  if i == 0
+    status = true
+    break;
+  end
+  i -= 1
+  for j in 0...3
+    status |= (c.data[j] != c63[i,j])
+  end
+  s1 = c.valid?
+  desc = sprintf("GSL::Combination#valid\(%u\)", i)
+  GSL::Test.test(s1, desc)
+end while c.prev == GSL::SUCCESS
+
+GSL::Test.test(status, "GSL::Combination#prev, 6 choose 3 combination, 20 steps")
+
+c.prev
+c.prev
+c.prev
+
+for j in 0...3
+  status |= (c.data[j] != c63[0,j])
+end
+GSL::Test.test(status, "GSL::Combination#prev on the first combination")
+
+s1 = c.valid?
+GSL::Test.test(s1, "GSL::Combination#valid on the first combination")
+d = GSL::Combination.alloc(6, 3)
+GSL::Combination.memcpy(d, c)
+
+status = false
+for j in 0...3 
+  status |= (d.data[j] != c.data[j])
+end
+GSL::Test.test(status, "GSL::Combination.memcpy, 6 choose 3 combination")
+
+c = GSL::Combination.calloc(7, 0)
+status |= (c.next != GSL::FAILURE)
+status |= (c.next != GSL::FAILURE)
+status |= (c.prev != GSL::FAILURE)
+status |= (c.prev != GSL::FAILURE)
+GSL::Test.test(status, "GSL::Combination 7 choose 0")
+
+c = GSL::Combination.calloc(7, 7)
+for j in 0...7
+  status |= (c.get(j) != j)
+end
+status |= (c.next != GSL::FAILURE)
+for j in 0...7
+  status |= (c.get(j) != j)
+end
+status |= (c.next != GSL::FAILURE)
+for j in 0...7
+  status |= (c.get(j) != j)
+end
+status |= (c.next != GSL::FAILURE)
+for j in 0...7
+  status |= (c.get(j) != j)
+end
+GSL::Test.test(status, "GSL::Combination 7 choose 7")

data/tests/complex.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require("gsl")
+require("./gsl_test.rb")
+include GSL::Test
+include Math
+
+for i in 0...10
+  r = (i - 5.0)*0.3
+  t = 2.0*M_PI*i/5.0
+  x = r*cos(t)
+  y = r*sin(t)
+  z = GSL::Complex.polar(r, t)
+  desc = sprintf("gsl_complex_polar real part at (r=%g,t=%g)", r, t)
+  GSL::Test.test_rel(z.real, x, 10*GSL::DBL_EPSILON, desc)
+  desc = sprintf("gsl_complex_polar imag part at (r=%g,t=%g)", r, t)
+  GSL::Test.test_rel(z.imag, y, 10*GSL::DBL_EPSILON, desc)
+end

data/tests/const.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# Ruby/GSL implementation of GSL "const/test.c"
+require("gsl")
+require("./gsl_test.rb")
+include GSL::Test
+include Math
+include GSL::CONST
+
+GSL::IEEE::env_setup()
+
+c = MKSA::SPEED_OF_LIGHT
+eps = MKSA::VACUUM_PERMITTIVITY
+mu = MKSA::VACUUM_PERMEABILITY
+GSL::Test.test_rel(c, 1.0/sqrt(eps*mu), 1e-6, "speed of light (mks)")
+
+ly = CGSM::LIGHT_YEAR
+c = CGSM::SPEED_OF_LIGHT
+y = 365.2425 * CGSM::DAY
+GSL::Test.test_rel(ly, c * y, 1e-6, "light year (cgs)")
+
+micro = NUM::MICRO
+mega = NUM::MEGA
+kilo = NUM::KILO
+GSL::Test.test_rel(mega/kilo, 1/(micro*kilo), 1e-10, "kilo (mega/kilo, 1/(micro*kilo))");

data/tests/deriv.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+# Ruby/GSL implementation of GSL "deriv/test.c"
+require("gsl")
+require("./gsl_test.rb")
+include GSL::Test
+
+include Math
+
+f1 = GSL::Function.alloc { |x| exp(x) }
+df1 = GSL::Function.alloc { |x| exp(x) }
+
+f2 = GSL::Function.alloc { |x| 
+  if x >= 0.0; x*sqrt(x);
+  else; 0.0; end
+}
+df2 = GSL::Function.alloc { |x| 
+  if x >= 0.0; 1.5*sqrt(x);
+  else; 0.0; end
+}
+
+f3 = GSL::Function.alloc { |x| 
+  if x != 0.0; sin(1.0/x);
+  else; 0.0; end
+}
+df3 = GSL::Function.alloc { |x| 
+  if x != 0.0; -cos(1.0/x)/(x*x);
+  else; 0.0; end
+}
+
+f4 = GSL::Function.alloc { |x| exp(-x*x) }
+df4 = GSL::Function.alloc { |x| -2.0*x*exp(-x*x) }
+
+f5 = GSL::Function.alloc { |x| x*x }
+df5 = GSL::Function.alloc { |x| 2.0*x }
+
+f6 = GSL::Function.alloc { |x| 1.0/x }
+df6 = GSL::Function.alloc { |x| -1.0/(x*x) }
+
+def test_deriv(deriv, f, df, x, desc)
+  expected = df.eval(x)
+  h = 1e-4
+  case deriv
+  when "central"
+    result, abserr = f.deriv_central(x, h)
+  when "forward"
+    result, abserr = f.deriv_forward(x, h)
+  when "backward"
+    result, abserr = f.deriv_backward(x, h)
+  else
+    raise("undefined operation")
+  end
+  GSL::Test::test_abs(result, expected, GSL::MIN(h, expected.abs) + GSL::DBL_EPSILON, desc)
+  if abserr < (result - expected).abs
+    GSL::Test::test_factor(abserr, (result - expected).abs, 2, desc + " error estimate")
+  elsif result == expected or expected == 0.0
+    GSL::Test::test_abs(abserr, 0.0, 1e-6, desc + " abserr")
+  else
+    d = (result - expected).abs
+    GSL::Test::test_abs(abserr, (result - expected).abs, 1e6*d, desc + " abserr")
+  end
+end
+
+test_deriv("central", f1, df1, 1.0, "exp(x), x=1, central deriv")
+test_deriv("forward", f1, df1, 1.0, "exp(x), x=1, forward deriv")
+test_deriv("backward", f1, df1, 1.0, "exp(x), x=1, backward deriv")
+
+test_deriv("central", f2, df2, 0.1, "x^(3/2), x=0.1, central deriv")
+test_deriv("forward", f2, df2, 0.1, "x^(3/2), x=0.1, forward deriv")
+test_deriv("backward", f2, df2, 0.1, "x^(3/2), x=0.1, backward deriv")
+
+test_deriv("central", f3, df3, 0.45, "sin(1/x), x=0.45, central deriv")
+test_deriv("forward", f3, df3, 0.45, "sin(1/x), x=0.45, forward deriv")
+test_deriv("backward", f3, df3, 0.45, "sin(1/x), x=0.45, backward deriv")
+
+test_deriv("central", f4, df4, 0.5, "exp(-x^2), x=0.5, central deriv")
+test_deriv("forward", f4, df4, 0.5, "exp(-x^2), x=0.5, forward deriv")
+test_deriv("backward", f4, df4, 0.5, "exp(-x^2), x=0.5, backward deriv")
+
+test_deriv("central", f5, df5, 0.0, "x^2, x=0, central deriv")
+test_deriv("forward", f5, df5, 0.0, "x^2, x=0, forward deriv")
+test_deriv("backward", f5, df5, 0.0, "x^2, x=0, backward deriv")
+
+test_deriv("central", f6, df6, 10.0, "1/x, x=10, central deriv")
+test_deriv("forward", f6, df6, 10.0, "1/x, x=10, forward deriv")
+test_deriv("backward", f6, df6, 10.0, "1/x, x=10, backward deriv")

data/tests/dht/dht1.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# Test gsl/dht/test.c: test_dht_exact()
+# Expected results:
+#  vout[0]=0.375254649407520
+#  vout[1]=(-0.133507872695560
+#  vout[2]=0.044679925143840
+
+require("gsl")
+vin = GSL::Vector.alloc(1, 2, 3)
+t = GSL::Dht.alloc(3, 1.0, 1.0)
+vout = t.apply(vin)
+p vout
+
+vin2 = t.apply(vout)
+vin2.scale!(13.323691936314223*13.323691936314223)
+p vin2
+

data/tests/dht/dht2.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# Test gsl/dht/test.c: test_dht_simple()
+# Expected results:
+#  vout[0]=4.00
+#  vout[5]=1.84
+#  vout[10]=1.27
+#  vout[35]=0.352
+#  vout[100]=0.0237
+
+require("gsl")
+
+N = 128
+t = GSL::Dht.alloc(N, 0.0, 100.0)
+vin = GSL::Vector.alloc(N)
+for n in 0...N do
+  x = t.x_sample(n)
+  vin[n] = 1.0/(1.0 + x*x)
+end
+
+vout = t.apply(vin)
+
+printf("%e %e %e %e %e\n", vout[0], vout[5], vout[10], vout[35], vout[100])
+

data/tests/dht/dht3.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# Test gsl/dht/test.c: test_dht_exp1()
+# Expected results:
+#  vout[0]=0.181
+#  vout[5]=0.357
+#  vout[10]=0.211
+#  vout[35]=0.0289
+#  vout[100]=0.00221
+
+require("gsl")
+
+N = 128
+t = GSL::Dht.alloc(N, 1.0, 20.0)
+vin = GSL::Vector.alloc(N)
+for n in 0...N do
+  x = t.x_sample(n)
+  vin[n] = Math::exp(-x)
+end
+
+vout = t.apply(vin)
+
+printf("%e %e %e %e %e\n", vout[0], vout[5], vout[10], vout[35], vout[100])
+

data/tests/dht/dht4.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# Test gsl/dht/test.c: test_dht_poly1()
+# Expected results:
+#  vout[0]=0.057274214
+#  vout[5]=-0.000190850
+#  vout[10]=0.000024342
+#  vout[35]=-4.04e-07
+#  vout[100]=1.0e-08
+
+require("gsl")
+
+N = 128
+t = GSL::Dht.alloc(N, 1.0, 1.0)
+vin = GSL::Vector.alloc(N)
+for n in 0...N do
+  x = t.x_sample(n)
+  vin[n] = x*(1.0 - x*x)
+end
+
+vout = t.apply(vin)
+
+printf("%e %e %e %e %e\n", vout[0], vout[5], vout[10], vout[35], vout[100])
+