gsl 1.12.109 → 1.14.5

data/examples/histogram/smp.dat

@@ -0,0 +1,5 @@
+ 0.0  20.0  1
+20.0  40.0 10
+40.0  60.0 15
+60.0  80.0  8
+80.0 100.0  2

data/examples/histogram/xexp.rb

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

data/examples/integration/ahmed.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# Ahmed's Integral
+# See e.g. http://mathworld.wolfram.com/AhmedsIntegral.html
+#
+require("gsl")
+include GSL
+include Math
+
+f = Function.alloc { |x| 
+  sqrtx22 = sqrt(x*x + 2)
+  atan(sqrtx22)/(sqrtx22*(x*x + 1))
+}
+
+val = f.qng(0, 1)[0]
+
+puts("Ahmed's integral")
+puts("Expect: 5pi^2/96 = #{5.0*M_PI*M_PI/96}")
+puts("QNG result:        #{val}")
+
+
+ 

data/examples/integration/cosmology.rb

@@ -0,0 +1,75 @@
+
+require("gsl")
+include GSL
+include GSL::CONST
+include GSL::CONST::CGSM
+include Math
+
+module Cosmology
+
+  # Inverse of H(z), H(z): Hubble parameter determined by Friedmann equation
+  InvHz = Function.alloc { |z, unv|
+    matter = unv.matter
+    radiation = unv.radiation
+    lambda = unv.lambda         # Cosmological constant
+    k = unv.k                   # Curvature
+    zplus1 = z + 1.0
+    z12 = zplus1*zplus1
+    1.0/sqrt(k*z12 + lambda + matter*z12*zplus1 + radiation*z12*z12)
+  }
+  WSpace = GSL::Integration::Workspace.alloc(1000)
+  
+  class Universe
+    H2H0 = 3.24e-18
+    G = GRAVITATIONAL_CONSTANT
+    RAD_DENSITY = 8.0*pow_5(PI)*pow_4(BOLTZMANN)/15.0/pow_3(PLANCKS_CONSTANT_H*SPEED_OF_LIGHT)
+    #  p SPEED_OF_LIGHT/(0.71*100*1e5*1e3)*13
+    
+    def initialize(matter = 0.3, lambda = 0.7, cmbT = 2.7, h = 0.7)
+      # Hubble parameter at present
+      @h = h
+      @H0 = H2H0*h
+      
+      # Density parameters
+      @matter = matter
+      @lambda = lambda
+      rad = RAD_DENSITY*pow_4(cmbT)
+      @radiation = rad*8*PI*G/3/@H0/@H0/SPEED_OF_LIGHT/SPEED_OF_LIGHT
+      @Omega = @matter + @lambda + @radiation
+      @k = 1.0 - @Omega
+      @q = @matter/2.0 + @radiation - @lambda  # Decceleration parameter
+    end
+    
+    def comoving_distance(z)
+      InvHz.set_params(self)
+      InvHz.integration_qags([0.0, z], WSpace)[0]
+    end
+    
+    # r: comoving distance
+    def conformal_factor(r)
+      tmp = sqrt(@k)
+      if @Omega > 1.0
+        sin(tmp*r)/tmp
+      elsif @Omega < 1.0
+        sinh(tmp*r)/tmp
+      else
+        r
+      end
+    end
+    
+    def luminosity_distance(z)
+      r = self.comoving_distance(z)
+      s = self.conformal_factor(r)
+      [r, (1.0 + z)*s]  # comoving distance, luminosity distance
+    end
+    
+    attr_reader :h
+    attr_reader :H0
+    attr_reader :matter
+    attr_reader :lambda
+    attr_reader :radiation
+    attr_reader :Omega
+    attr_reader :k
+    attr_reader :q
+  end
+end

data/examples/integration/friedmann.gp

@@ -0,0 +1,16 @@
+#set terminal postscript eps enhanced color
+#set output 'tmp.eps'
+set xlabel 'Redshift z'
+set ylabel 'Luminosity Distance [1/H0]'
+set ytics nomirror
+set grid
+set y2tics
+set yrange [0:13]
+set y2range [0:54.89]
+#set logscale xy
+#set logscale y2
+#set yrange [0.01:11]
+#set y2range [0.04:60]
+
+set y2label 'Luminosity Distance [Gpc] (h = 0.71)'
+plot 'friedmann.dat' u 1:3 title 'Matter = 1, Lambda = 0 (Einstein - de Sitter)' w l lw 3, '' u 1:5 title 'Matter = 0.27, Lambda = 0.73 (WMAP, Lambda-CDM)' w l lw 3, '' u 1:7 title 'Matter = 0, Lambda = 1 (de Sitter)' w l lw 3

data/examples/integration/friedmann.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# Calculate the redshift-distance relation
+# for Friedmann universe
+require("./cosmology")
+include Cosmology
+
+# Matter = 1, Lambda = 0, Radiation = 0
+u10 = Universe.new(1.0, 0.0, 0.0)
+
+# Matter = 0.27, Lambda = 0.73, Radiation = 0
+u37 = Universe.new(0.27, 0.73, 0.0)
+
+# Matter = 0.0, Lambda = 1.0, Radiation = 0
+u01 = Universe.new(0.0, 1.0, 0.0)
+
+begin
+  file = File.open("friedmann.dat", "w")
+  z = 0.01
+  while z <= 3
+    # comoving distance, luminosity distance
+    chi10, ldist10 = u10.luminosity_distance(z)  
+    chi37, ldist37 = u37.luminosity_distance(z)  
+    chi01, ldist01 = u01.luminosity_distance(z)  
+    file.printf("%e %e %e %e %e %e %e\n", 
+                z, chi10, ldist10, chi37, ldist37, chi01, ldist01)
+    z += 0.1
+  end
+ensure
+  file.close
+end
+
+#puts("Data file \"friedmann.dat\" created.")
+#puts("Try \"gnuplot -persist friedmann.gp\"")
+system("gnuplot -persist friedmann.gp")
+File.delete("friedmann.dat")

data/examples/integration/gamma-zeta.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+include Math
+
+w = Integration::Workspace.alloc(1000)
+xmin = 0.0
+
+f = Function.alloc{ |x, n|
+  pow(x, n-1)/(exp(x) - 1.0)
+}
+
+nv = Vector[2..5]
+y1 = Sf::gamma(nv)*Sf::zeta(nv)
+
+y2 = Vector[10]
+begin
+  file1 = File.open("y1.dat", "w")
+  file2 = File.open("y2.dat", "w")
+  nv.each do |n|
+    f.set_params(n)
+    y2[n.to_i-2] = f.qagiu(xmin, w)[0]
+    file1.printf("%e %e\n", n, y1[n.to_i-2])
+    file2.printf("%e %e\n", n, y2[n.to_i-2])
+  end
+ensure
+  file1.close
+  file2.close
+end
+
+system("graph -T X -C -g 3 -m 1 'y2.dat' -m -2 -S 4 'y1.dat' ")
+File.delete("y1.dat")
+File.delete("y2.dat")
+
+

data/examples/integration/integration.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+require("gsl")
+include Math
+
+proc = Proc.new{ |x, alpha|
+  log(alpha*x)/sqrt(x)
+}
+
+f = GSL::Function.alloc(proc)
+f.set_params(1.0)
+
+expected = -4.0
+
+#result, error, neval = f.integration_qags([0.0, 1.0], 0.0, 1.0e-7, 1000)
+#result, error, neval = f.integration_qags([0.0, 1.0])
+result, error, neval = f.qags([0.0, 1.0])
+
+printf("result          = %.18f\n", result);
+printf("exact result    = %.18f\n", expected);
+printf("estimated error = %.18f\n", error);
+printf("actual error    = %.18f\n", result - expected);
+printf("intervals =  %d\n", neval);

data/examples/integration/qag.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require("gsl")
+include Math
+
+f = GSL::Function.alloc { |x| x*sin(1.0/x) }
+w = GSL::Integration::Workspace.alloc(1000)
+
+p f.qag(0, 3, w)

data/examples/integration/qag2.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+# Singular at x = 0
+
+f = GSL::Function.alloc { |x| 1.0/Math::sqrt(x) }
+
+puts("QAG")
+p f.qag(0, 1)
+p f.qag([0, 1])
+
+p GSL::Integration.qag(f, 0, 1)
+p GSL::Integration.qag(f, [0, 1])
+

data/examples/integration/qag3.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require("gsl")
+include Math
+
+f = GSL::Function.alloc { |x| x*sin(1.0/x)*sqrt((1 - x).abs) }
+w = GSL::Integration::Workspace.alloc(1000)
+
+p f.qag(0, 3, w)

data/examples/integration/qagi.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+include Math
+
+printf("QAGI (integrate [-infty:+infty])\n\n")
+
+w = Integration::Workspace.alloc(1000)
+
+f = Function.alloc{ |x, a|
+  cos(x)/(x*x + a*a)
+}
+
+a = 1.0
+f.set_params(a)
+printf("Case 1: f(x; a) = cos(x)/(x^2 + a^2), I(a) = pi/a e^(-a)\n")
+printf("        Expected: I(1) = %10.9f\n", M_PI*exp(-a))
+printf("        QAGI Result:     %10.9f\n", f.qagi([0, 1e-4], w)[0])
+
+f = Function.alloc{ |x, a|
+  exp(a*x)/(1 + exp(x))
+}
+
+a = 0.3
+f.set_params(a)
+printf("Case 2: f(x; a) = e^{ax}/(1 + e^x), I(a) = pi/sin(a pi)\n")
+printf("        Expected: I(0.3) = %10.9f\n", M_PI/sin(a*M_PI))
+printf("        QAGI Result:       %10.9f\n", f.qagi([0, 1e-2], w)[0])

data/examples/integration/qagi2.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+require 'gsl'
+include GSL
+include Math
+
+f = Function.alloc{ |x|
+  exp(-x*x)
+}
+
+exact = sqrt(PI)
+
+result, = f.qagi
+puts("QAGI")
+puts("exp(-x*x), x = -infty --- +infty")
+printf("exact  = %.18f\n", exact)
+printf("result = %.18f\n\n", result)
+
+p Integration.qagi(f)
+
+w = Integration::Workspace.alloc(1000)
+xmin = 0.0
+
+puts("QAGIU")
+result, = f.integration_qagiu(xmin, [0, 1e-6], w)
+puts("exp(-x*x), x = 0 --- +infty")
+printf("exact  = %.18f\n", exact/2)
+printf("result = %.18f\n", result)
+p w.to_a
+
+p Integration.qagiu(f, xmin)
+
+puts("QAGIL")
+result, = f.integration_qagil(0.0, 0.0, 1e-7, 1000, w)
+puts("exp(-x*x), x = -infty --- 0")
+printf("exact  = %.18f\n", exact/2)
+printf("result = %.18f\n\n", result)
+
+f455 = Function.alloc { |x|
+  log(x)/(1.0 + 100.0*x*x)
+}
+
+exp_result = -3.616892186127022568E-01
+exp_abserr = 3.016716913328831851E-06
+
+result = f455.qagiu(0.0, [0.0, 1e-3])
+p result
+puts("exp_result: #{exp_result}")
+puts("exp_abserr: #{exp_abserr}")
+

data/examples/integration/qagiu.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+include Math
+
+printf("QAGIU (integrate [0:+infty])\n\n")
+
+w = Integration::Workspace.alloc(1000)
+xmin = 0.0
+
+f1 = Function.alloc{ |x, a|
+  1.0/(pow_4(x) + pow_4(a))
+}
+
+printf("Case 1: f(x; a) = 1/(x^4 + a^4), I(a) = pi/2sqrt2/a^3\n")
+a = 1.0
+printf("        Expected: I(1) = %10.9f\n", M_PI/2/M_SQRT2)
+f1.set_params(a)
+printf("        QAGIU Result:    %10.9f\n\n", f1.qagiu(xmin, w)[0])
+
+f2 = Function.alloc{ |x, a|
+  x*x/(pow_4(x) + pow_4(a))
+}
+
+printf("Case 2: f(x; a) = 1/(x^4 + a^4), I(a) = pi/2sqrt2/a\n")
+a = 2.0
+printf("        Expected: I(2) = %10.9f\n", M_PI/2/M_SQRT2/a)
+f2.set_params(a)
+printf("        QAGIU Result:    %10.9f\n\n", f2.qagiu(xmin, w)[0])

data/examples/integration/qagp.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+require 'gsl'
+include GSL
+include Math
+
+f454 = Function.alloc{ |x|
+  x2 = x*x
+  x3 = x2*x
+  x3*log(((x2-1)*(x2-2)).abs)
+}
+exp_result = 5.274080611672716401E+01
+exp_abserr = 1.755703848687062418E-04
+pts = [0, 1, sqrt(2), 3]
+result = f454.qagp(pts, 0.0, 1e-3)
+p result
+
+puts("exp_result: #{exp_result}")
+puts("exp_abserr: #{exp_abserr}")
+
+p Integration.qagp(f454, pts, [0.0, 1e-3])

data/examples/integration/qags.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+
+# Singular at x = 0
+f = Function.alloc { |x| 1.0/Math::sqrt(x) }
+
+puts("QAGS")
+p f.qags(0, 1)
+p f.qags([0, 1])
+
+p Integration.qags(f, 0, 1)
+p Integration.qags(f, [0, 1])
+

data/examples/integration/qawc.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+require 'gsl'
+include GSL
+include Math
+
+f459 = Function.alloc { |x|
+  1.0/(5.0*x*x*x + 6.0)
+}
+
+exp_result = -8.994400695837000137E-02
+exp_abserr = 1.185290176227023727E-06
+
+result = f459.qawc([-1.0, 5.0], 0, [0.0, 1e-3])
+p result
+puts("exp_result: #{exp_result}")
+puts("exp_abserr: #{exp_abserr}")
+
+p Integration.qawc(f459, [-1.0, 5.0], 0)

data/examples/integration/qawf.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+require 'gsl'
+include GSL
+include Math
+
+f457 = Function.alloc { |x|
+  if x.zero?
+    val = 0.0
+  else
+    val = 1.0/sqrt(x)
+  end
+  val
+}
+
+exp_result =  9.999999999279802765E-01
+exp_abserr =  1.556289974669056164E-08
+
+table = [PI/2.0, 1.0, GSL::Integration::COSINE, 1000]
+result = f457.qawf(0.0, 1e-7, table)
+p result
+puts("exp_result: #{exp_result}")
+puts("exp_abserr: #{exp_abserr}")
+
+w = Integration::Workspace.alloc
+wc = Integration::Workspace.alloc
+
+limit = 1000
+table = Integration::QAWO_Table.alloc(PI/2.0, 1.0, GSL::Integration::COSINE, 1000)
+p f457.qawf(0.0, table)
+p f457.qawf(0.0, 1e-7, table)
+p f457.qawf(0.0, 1e-7, limit, table)
+p f457.qawf(0.0, limit, table)
+p f457.qawf(0.0, 1e-7, limit, w, wc, table)
+p f457.qawf(0.0, w, wc, table)
+p f457.qawf(0.0, limit, w, wc, table)
+#p f457.qawf(0.0, limit, w, table)
+
+p Integration.qawf(f457, 0.0, table)
+p Integration.qawf(f457, 0.0, 1e-7, table)
+p Integration.qawf(f457, 0.0, 1e-7, limit, table)
+p Integration.qawf(f457, 0.0, limit, w, wc, table)