gsl 1.12.109 → 1.14.5

data/{README.rdoc → README}

@@ -1,3 +1,4 @@
+=begin
 == Description
 Ruby/GSL, a ruby interface to GSL (GNU Scientific library)
 
@@ -27,3 +28,5 @@ submit reports from http://rubyforge.org/projects/rb-gsl/.
 == Author
 Yoshiki Tsunesada
 y-tsunesada at mm dot em-net dot ne dot jp
+
+=end

data/Rakefile

@@ -1,10 +1,13 @@
 require 'rubygems'
 require 'rake/gempackagetask'
+require 'rake/rdoctask'
+
+RB_GSL_VERSION = File.readlines('VERSION')[0].chomp
 
 spec = Gem::Specification.new do |s|
   # Basics
   s.name = 'gsl'
-  s.version = File.readlines('VERSION')[0].chomp
+  s.version = RB_GSL_VERSION
   s.summary = 'Ruby interface to GSL'
   s.description = 'RubyGSL is a Ruby interface to the GNU Scientific Library, for numerical computing with Ruby'
   #s.platform = Gem::Platform::Ruby
@@ -21,12 +24,20 @@ spec = Gem::Specification.new do |s|
 
   # Files, Libraries, and Extensions
   s.files = FileList[
-    'README.rdoc',
-    'VERSION',
+    'AUTHORS',
+    'COPYING',
+    'ChangeLog',
+    'README',
     'Rakefile',
+    'setup.rb',
+    'THANKS',
+    'VERSION',
+    'examples/**/*',
     'ext/*',
     'lib/**/*',
-    'include/*'
+    'include/*',
+    'rdoc/*',
+    'tests/**/*'
   ].to_a
   s.require_paths = ['lib', 'lib/gsl', 'lib/ool', 'ext']
   #s.autorequire = nil
@@ -37,18 +48,51 @@ spec = Gem::Specification.new do |s|
   # C compilation
   s.extensions = %w[ ext/extconf.rb ]
 
-  # Documentation TODO
-  #s.rdoc_options = []
-  #s.has_rdoc = false
-  #s.extra_rdoc_files = []
+  # Documentation
+  s.has_rdoc = true
+  s.rdoc_options = [
+    '--title', 'Ruby/GSL',
+    '--main', 'rdoc/index.rdoc',
+    '--exclude', 'ext/',
+    '--exclude', 'include/',
+    '--exclude', 'lib/',
+  ]
+  s.extra_rdoc_files = FileList['rdoc/*'].to_a
 
   # Testing TODO
   #s.test_files = []
 end
 
-Rake::GemPackageTask.new(spec) do |pkg|
+Rake::PackageTask.new('rb-gsl', RB_GSL_VERSION) do |pkg|
   pkg.need_zip = true
   pkg.need_tar = true
+  pkg.package_files = spec.files
 end
 
-task :default => :gem
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = false
+  pkg.need_tar = false
+end
+
+task :default => [:package, :gem]
+
+# --------------------------------------------------------------------
+# Create a task to build the RDOC documentation tree.
+
+desc "Create the RDoc html files"
+Rake::RDocTask.new("rdoc") { |rdoc|
+  rdoc.rdoc_dir = 'html'
+  rdoc.title    = 'Ruby/GSL'
+  rdoc.main     = 'rdoc/index.rdoc'
+  rdoc.options << '--exclude' << 'ext/'
+  rdoc.options << '--exclude' << 'include/'
+  rdoc.options << '--exclude' << 'lib/'
+  rdoc.rdoc_files.include('rdoc/*.rdoc')
+}
+
+desc "Publish the RDoc files on RubyForge"
+task :pub_rdoc => ["html/index.html"] do
+  mkdir_p "emptydir"
+  sh "scp -rq html/* www.rubyforge.org:/var/www/gforge-projects/rb-gsl/."
+  rm_r "emptydir"
+end

data/THANKS

@@ -0,0 +1,17 @@
+Takeshi Horinouchi
+Masahide Kikkawa 
+Seiya Nishizawa (Patches, NArray supports)
+Arno Erpenbeck (ruby-gsl project)
+Austin Newton
+Jordi Burguet Castell (gsl_tensor)
+Cameron McBride (Patches, vector/block manipulations)
+KOSHIRO Tsuyoshi (patches)
+GSL development team
+zunda (patches)
+Christopher Butler
+Andrea Censi <andrea.censi@dis.uniroma1.it> (Bug report on Vector#*)
+Daigo Moriwaki (Bug report)
+Joe Wölfel (Ruby-1.9 support)
+Cyrus Hall (patch for Ruby-1.9)
+Dave MacMahon (patch for FFT and interface refinements)
+Roman Shterenzon (Non-negative Matrix Factorization)

data/VERSION

@@ -1,2 +1 @@
-1.12.90
-
+1.14.5

data/examples/alf/alf.gp

@@ -0,0 +1,15 @@
+set multiplot
+set size 0.5, 0.5
+set grid
+
+set origin 0, 0.5
+plot "alf.dat" u 1:2, sin(x)
+
+set origin 0.5, 0.5
+plot "alf.dat" u 1:3, 3*cos(x)*sin(x)
+
+set origin 0, 0
+plot "alf.dat" u 1:4, 3*sin(x)*sin(x)
+
+set origin 0.5, 0
+plot "alf.dat" u 1:5, 1.5*sin(x)*(5*cos(x)*cos(x)-1)

data/examples/alf/alf.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+exit unless GSL.const_defined?("ALF")
+
+lmax = 3
+#w = GSL::ALF::Workspace.alloc(lmax)
+#w = GSL::ALF.alloc(lmax)
+w = GSL::alf_alloc(lmax)
+w.params(0, 0, GSL::ALF::NORM_NONE)
+
+
+result = GSL::Vector.alloc(GSL::ALF::array_size(lmax))
+deriv = GSL::Vector.alloc(GSL::ALF::array_size(lmax))
+
+ind11 = GSL::ALF::array_index(1, 1)
+ind21 = GSL::ALF::array_index(2, 1)
+ind22 = GSL::ALF::array_index(2, 2)
+ind31 = GSL::ALF::array_index(3, 1)
+
+File.open("alf.dat", "w") do |f|
+  theta = 0.01
+  while theta < 1.99*Math::PI do
+    x = Math.cos(theta)
+#    w.Plm_deriv_array(lmax, x, result, deriv)
+    w.Plm_array(lmax, x, result, deriv)
+    f.printf("%e %e %e %e %e\n", theta, result[ind11], result[ind21], result[ind22], result[ind31])
+    theta += 0.01
+  end
+end
+
+system("gnuplot -persist alf.gp")

data/examples/blas/blas.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+a = GSL::Vector[0.11, 0.12, 0.13, 0.21, 0.22, 0.23]
+b = GSL::Vector[1011, 1012, 1021, 1022, 1031, 1032]
+
+A = a.matrix_view(2, 3)
+B = b.matrix_view(3, 2)
+
+C = GSL::Blas.dgemm(GSL::Blas::NoTrans, GSL::Blas::NoTrans, 1.0, A, B, 0.0)
+p C
+
+p A*B 

data/examples/blas/dnrm2.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require("gsl")
+include Math
+
+m = GSL::Matrix.alloc(10, 10)
+for i in 0...10
+  for j in 0...10
+    m.set(i, j, sin(i) + cos(j))
+  end
+end
+
+for j in 0...10
+  col = m.col(j)
+  d = GSL::Blas.dnrm2(col)
+  printf("matrix column %d, norm = %g\n", j, d)
+end

data/examples/blas/level1.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+include GSL::Blas
+
+x = GSL::Vector[1, 2, 3]
+y = GSL::Vector[4, 5, 6]
+
+p x.blas_ddot(y)
+p GSL::Blas.ddot(x, y)
+
+xz = GSL::Vector::Complex.alloc([1, 0], [2, 0], [3, 0])
+yz = GSL::Vector::Complex.alloc([4, 0], [5, 0], [6, 0])
+p zdotu(xz, yz)
+
+p x.nrm2
+p GSL::Blas.dnrm2(x)
+p xz.nrm2
+p GSL::Blas.dznrm2(xz)
+
+p x.asum
+p GSL::Blas.dasum(x)
+p xz.asum
+p GSL::Blas.dzasum(xz)
+
+x.swap(y)
+p x
+p y
+
+GSL::Blas.dswap(x, y)
+p x
+p y
+
+xz.swap(yz)
+p xz
+p yz
+
+GSL::Blas.zswap(xz, yz)
+p xz
+p yz
+
+p x.axpy(2, y)
+p y
+p GSL::Blas.daxpy(2, x, y)
+p y
+
+p x.axpy!(2, y)
+p y
+p GSL::Blas.daxpy!(2, x, y)
+p y
+
+y = GSL::Vector[4, 5, 6]
+
+az = GSL::Complex.alloc(2, 0)
+p xz.zaxpy(az, yz)
+p yz
+p GSL::Blas.zaxpy(az, xz, yz)
+p yz
+
+az = GSL::Complex[2, 0]
+p xz.axpy!(az, yz)
+p yz
+p GSL::Blas.zaxpy!(az, xz, yz)
+p yz
+
+yz = GSL::Vector::Complex.alloc([4, 0], [5, 0], [6, 0])
+
+p x.scal(2)
+p x
+
+p x.scal!(2)
+p x
+
+x = GSL::Vector[1, 2, 3]
+
+p xz.zscal(az)
+p xz.zdscal(2)
+
+p y
+p GSL::Blas.drot(x, y, 2, 3)
+p drot(x, y, 2, 3)

data/examples/blas/level2.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL::Blas
+
+x = GSL::Vector[1, 2, 3]
+y = GSL::Vector[4, 5, 6]
+
+A = GSL::Matrix.alloc([1, 2, 3], [4, 5, 6], [7, 8, 9])
+# [28, 64, 100]
+p GSL::Blas.dgemv(CblasNoTrans, 2, A, x)
+p dgemv(CblasNoTrans, 2, A, x)

data/examples/blas/level3.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL::Blas
+
+a = GSL::Matrix.alloc([1, 5], [4, 6])
+b = GSL::Matrix.alloc([10, 2], [3, 8])
+c = GSL::Matrix.alloc(2, 2)
+
+p GSL::Blas.dgemm(NoTrans, NoTrans, 1, a, b, 1, c)
+p GSL::Blas.dgemm(a, b)
+p a*b
+

data/examples/bspline.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+N = 200
+NCOEFFS = 8
+NBREAK = NCOEFFS - 2
+
+GSL::Rng::env_setup()
+r = GSL::Rng.alloc()
+
+bw = GSL::BSpline.alloc(4, NBREAK)
+B = GSL::Vector.alloc(NCOEFFS)
+x = GSL::Vector.alloc(N)
+y = GSL::Vector.alloc(N)
+xx = GSL::Matrix.alloc(N, NCOEFFS)
+w = GSL::Vector.alloc(N)
+
+#printf("#m=0,S=0\n")
+for i in 0...N do
+  xi = (15.0/(N-1)/1)*i
+  yi = Math::cos(xi)*Math::exp(-0.1*xi)
+  
+  sigma = 0.1
+  dy = GSL::Ran.gaussian(r, sigma)
+  yi += dy
+  
+  x[i] = xi
+  y[i] = yi
+  w[i] = sigma
+  
+#  printf("%f %f\n", xi, yi)
+end
+
+bw.knots_uniform(0.0, 15.0)
+
+for i in 0...N do
+  xi = x[i]
+  bw.eval(xi, B)
+  for j in 0...NCOEFFS do
+    xx[i,j] = B[j]
+  end
+end
+
+c, cov, chisq = GSL::MultiFit.wlinear(xx, w, y)
+
+#printf("#m=0,S=0\n")
+
+x2 = GSL::Vector.linspace(0, 15, 150)
+y2 = GSL::Vector.alloc(150)
+x2.each_index do |i|
+  bw.eval(x2[i], B)
+  yi, yerr = GSL::MultiFit::linear_est(B, c, cov)
+  y2[i] = yi
+#  printf("%f %f\n", xi, yi)
+end
+
+GSL::graph([x, y], [x2, y2], "-T X -C -X x -Y y -x 0 15 -y -1 1.3")

data/examples/cdf.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+x = 2.0
+
+P = GSL::Cdf::ugaussian_P(x);
+printf("prob(x < %f) = %f\n", x, P);
+
+Q = GSL::Cdf::ugaussian_Q(x);
+printf("prob(x > %f) = %f\n", x, Q);
+
+x = GSL::Cdf::ugaussian_Pinv(P);
+printf("Pinv(%f) = %f\n", P, x);
+
+x = GSL::Cdf::ugaussian_Qinv(Q);
+printf("Qinv(%f) = %f\n", Q, x);

data/examples/cheb.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+f = GSL::Function.alloc { |x|
+  if x < 0.5
+    0.25
+  else
+    0.75
+  end
+}
+
+n = 1000
+order = 40
+cs = GSL::Cheb.alloc(order)
+
+x = GSL::Vector.linspace(0, 1, n)
+ff = f.eval(x)
+cs.init(f, 0, 1)
+r10 = cs.eval_n(10, x)
+r40 = cs.eval(x)
+GSL::graph(x, ff, r10, r40)

data/examples/combination.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+c = 0
+printf("All subsets of {0,1,2,3} by size:\n") ;
+for i in 0...4 do
+  c = GSL::Combination.calloc(4, i);
+  begin
+    printf("{");
+    c.fprintf(STDOUT, " %u");
+    printf(" }\n");
+  end while c.next == GSL::SUCCESS
+end
+
+p c
+c2 = c.clone
+p c2
+
+a = c.data
+p a.class
+p a
+p a.print
+

data/examples/complex/RC-lpf.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+# Transfer function of a RC low-pass filter
+require("gsl")
+include GSL::CONST::NUM
+
+class RC_LPF
+  def initialize(r, c)
+    @r = r
+    @c = c
+    @fp = 1.0/(2*Math::PI*r*c)
+    @omegap = 1.0/(r*c)
+    puts("Pole at #{fp} Hz")
+  end
+
+  def Vout(f)
+    if f.class == GSL::Vector
+      out = GSL::Vector::Complex[f.size]
+      i = 0
+      f.each do |freq|
+        a = 1.0/GSL::Complex[1.0, freq/@fp]
+        out[i] = a
+        i += 1
+      end
+      return out
+    else
+      1.0/GSL::Complex(1.0, f/@fp)
+    end
+  end
+
+  attr_reader :r, :c, :fp
+end
+
+# Create RC filter
+R = 1*KILO    # 1 [kOhm]
+C = 1*MICRO   # 1 [muF]
+lpf = RC_LPF.new(R, C)
+
+# Frequency, 1Hz - 10kHz, 100 divisions
+f = GSL::Vector.logspace2(1, 10*KILO, 100)
+
+# Transfer function
+tf = lpf.Vout(f)
+
+GSL::graph([f, tf.amp.dB], "-C -l x -g 3 -y -100 10 -X 'Frequency [Hz]' -Y 'dB' --toggle-rotate-y-label")
+GSL::graph([f, tf.phase/Math::PI], "-C -l x -g 3 -X 'Frequency [Hz]' -Y 'Phase [Pi]' --toggle-rotate-y-label")
+
+