rb-gsl 1.15.3.1

data/examples/vector/diff.rb

@@ -0,0 +1,31 @@
+#!/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 Vector of x values
+x = GSL::Vector.linspace(1, 5, 5)
+
+# Create Vector y = x**5
+y = GSL::pow_5(x)
+
+# Compute succesive differences
+y1 = y.diff
+y2 = y1.diff
+y3 = y2.diff
+y4 = y3.diff
+
+# Show that successive differences can be computed directly from y
+y.diff(2) == y2
+y.diff(3) == y3
+y.diff(4) == y4
+
+# Plot x and y Vectors
+GSL::graph(x, y, y1, y2, y3, "-C -g 3 -l x -l y -x 1 5 1")
+END

data/examples/vector/filescan.rb

@@ -0,0 +1,17 @@
+#!/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
+# Read file "c.dat" as doubles
+a, b, c, d = GSL::Vector.filescan("c.dat")
+
+# Read file "c.dat" as ints
+a, b, c, d = GSL::Vector::Int.filescan("c.dat")
+END

data/examples/vector/floor.rb

@@ -0,0 +1,23 @@
+#!/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 test Vector
+v = GSL::Vector[1.1, 2.7, 3.5, 5.8, -1.2, -2.8, -3.5]
+
+# Show result of #floor
+v.floor
+
+# Show result of #ceil
+v.ceil
+
+# Show result of #round
+v.round
+END

data/examples/vector/get_all.rb

@@ -0,0 +1,82 @@
+#!/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
+# These examples show all(?) the ways that Vector#get or its alias Vector#[]
+# can be invoked.  For a single Fixnum argument, a single element is returned.
+# For a single Array or GSL::Permutation argument, a new GSL::Vector containing
+# the specified elements, in the specified order, is returned.  For all other
+# cases, Vector#get is essentially an alias for Vector#subvector.  See
+# examples/vector/view_all.rb for more examples.
+
+# Create test vector v
+v = GSL::Vector.indgen(9)
+
+# Vector#[] with zero args returns a Vector::View of entire Vector
+v[]
+
+# Vector#[] with one Fixnum argument, i, returns the i'th element if i is
+# positive or the (size+i)'th element if i is negative.
+v[3]
+v[-3]
+
+# Vector#[] with single Array argument.  Notice the inner pair of brackets!
+v[[1,4,-9]]
+
+# Vector#[] with a single GSL::Permutation argument.
+p = GSL::Permutation.calloc(4).reverse
+v[p]
+
+# Vector#[] with one Range argument returns a Vector::View of the specified
+# elements.  If the begin value is greater than the end value, the View will
+# have the elements in reverse order.  If begin and/or end value is negative,
+# the value is taken to be "size-n".
+v[1..4]
+v[4..1]
+v[1...4]
+v[4...1]
+
+v[4..-2]
+v[-2..4]
+v[4...-2]
+v[-2...4]
+
+v[-4..8]
+v[8..-4]
+v[-4...8]
+v[8...-4]
+
+v[-5..-2]
+v[-2..-5]
+v[-5...-2]
+v[-2...-5]
+
+# Vector#[] with a Range argument and a Fixnum argument is like a single
+# Range argument, but with a stride given by the Fixnum argument.
+v[1..7, 3]
+v[7..1, 3]
+v[1...7, 3]
+v[7...1, 3]
+
+# Vector#[] with two Fixnum arguments is offset, length.  If offset is
+# negative, it means size+offset.  If length is negative, it means step is -1.
+v[2, 4]
+v[4, 2]
+v[-4, 2]
+v[-2, -4]
+
+# Vector#[] with three Fixnum arguments is offset, stride, length.  If offset
+# is negative, it means size+offset.  If length is negative, the sign of both
+# stride and length is inverted.
+v[1, 2, 3]
+v[1, -2, -3]
+v[-1, -2, 3]
+v[-1, 2, -3]
+END

data/examples/vector/gnuplot.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+# Turn on warnings
+$-w = true
+
+require 'gnuplot'
+require 'gsl'
+require 'gsl/gnuplot';
+
+# Plot using gnuplot
+Gnuplot.open do |gp|
+  Gnuplot::Plot.new( gp ) do |plot|
+  
+    plot.xrange "[0:10]"
+    plot.yrange "[-1.5:1.5]"
+    plot.title  "Sin Wave Example"
+    plot.xlabel "x"
+    plot.ylabel "sin(x)"
+    plot.pointsize 3
+    plot.grid 
+
+    x = GSL::Vector[0..10]
+    y = GSL::Sf::sin(x)
+
+    plot.data = [
+      Gnuplot::DataSet.new( "sin(x)" ) { |ds|
+	ds.with = "lines"
+	ds.title = "String function"
+	ds.linewidth = 4
+      },
+      
+      Gnuplot::DataSet.new( [x, y] ) { |ds|
+	ds.with = "linespoints"
+	ds.title = "Array data"
+      }
+    ]
+
+  end
+end

data/examples/vector/graph.rb

@@ -0,0 +1,28 @@
+#!/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 Vector to plot
+y1 = GSL::Vector[0.2, 3, 2, 0.4, 0, 4, 0]
+
+# Plot it using #graph()
+y1.graph
+
+# Create x and y2 Vectors
+x = GSL::Vector.linspace(0, 10, 50)
+
+y2 = GSL::Sf::bessel_J0(x)
+
+# Plot x vs y using #graph(x)
+y2.graph(x)
+
+# Plot y1 and x vs y2 using GSL::Vector.graph
+GSL::Vector.graph([nil, y1], [x, y2])
+END

data/examples/vector/histogram.rb

@@ -0,0 +1,22 @@
+#!/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 10,000 random numbers from Gaussian distribution
+N = 10000
+r = GSL::Rng.alloc
+v = r.gaussian(1.0, N)    # Generate N random numbers
+
+# Bin them into 50 bins spanning -4 to +4
+h = v.histogram(50, [-4, 4])
+
+# Plot them using graph
+h.graph("-T X -C -g 3")
+END

data/examples/vector/linspace.rb

@@ -0,0 +1,24 @@
+#!/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 Vector of 10 elements increasing linearly
+# from 0 to 5, inclusive, using Vector.linspace
+v = GSL::Vector.linspace(0, 5, 10)
+
+# Plot v
+v.graph("-C -Y v -S 4 -L 'Vector.linspace(0, 5, 10)'")
+
+# Create Vector of 11 elements from 0 to 5, inclusive, using Vector.linspace
+v = GSL::Vector.linspace(0, 5, 11)
+
+# Plot v
+v.graph("-C -Y v -S 4 -L 'Vector.linspace(0, 5, 11)'")
+END

data/examples/vector/log.rb

@@ -0,0 +1,17 @@
+#!/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 test Vector containing the first few powers of 10
+v = GSL::Vector[1, 10, 100, 1000, 10000]
+
+# Take log10 of v
+v.log10
+END

data/examples/vector/logic.rb

@@ -0,0 +1,33 @@
+#!/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 test Vectors
+a = GSL::Vector[1, 0, 3, 0]
+b = GSL::Vector[3, 4, 0, 0]
+
+# Show result of (a AND b)
+a.and(b)
+b.and(a)
+
+# Show result of (a OR b)
+a.or(b)
+b.or(a)
+
+# Show result of (a XOR b)
+a.xor(b)
+b.xor(a)
+
+# Show result of (NOT a)
+p a.not
+
+# Show result of (NOT b)
+p b.not
+END

data/examples/vector/logspace.rb

@@ -0,0 +1,25 @@
+#!/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 Vector of 10 elements increasing logarithmically
+# from 0 to 10000, inclusive, using Vector.logspace
+v = GSL::Vector.logspace(0, 4, 10)
+
+# Plot v
+v.graph("-C -Y v -l y -S 4 -L 'Vector.logspace(0, 4, 10)'")
+
+# Create Vector of 10 elements increasing logarithmically
+# from 0 to 10000, inclusive, using Vector.logspace2
+v = GSL::Vector.logspace2(1, 10000, 10)
+
+# Plot v
+v.graph("-C -Y v -l y -S 4 -L 'Vector.logspace2(1, 10000, 10)'")
+END

data/examples/vector/minmax.rb

@@ -0,0 +1,47 @@
+#!/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 test Vector
+a = GSL::Vector.alloc(1, 2, 3, 4, 5)
+
+# Find maximum
+a.max
+
+# Find minimum
+a.min
+
+# Find minimum and maximum
+a.minmax
+
+# Find index of maximimum
+a.max_index
+
+# Find index of minimimum
+a.min_index
+
+# Find indices of minimum and maximum
+a.minmax_index
+
+# Show that #isnull returns 0 for non-null Vector
+a.isnull
+
+# Show that #isnull? returns false for non-null Vector
+a.isnull?
+
+# Set all elements to zero
+a.set_zero
+
+# Show that #isnull returns 1 for null Vector
+a.isnull
+
+# Show that #isnull? returns true for null Vector
+a.isnull?
+END

data/examples/vector/mul.rb

@@ -0,0 +1,49 @@
+#!/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 test Vectors
+a = GSL::Vector.alloc(1, 2, 3, 4, 5)
+b = GSL::Vector.alloc(6, 7, 8, 9, 10)
+
+# Show element-wise multiplication
+a * b
+
+# Show that *= is not an in-place operation
+# (it sets receiver to new object).
+a.object_id
+a *= b
+a.object_id
+
+# Show that #mul! is a true in-place operation
+# (object_id does not change).
+a.object_id
+a.mul!(b)
+a.object_id
+
+# Same as "a = a / b" (element-wise division)
+a /= b
+
+# Show multiply by constant
+a * 2
+
+# Show coersion
+2 * a
+
+# Show coersion
+5 / a
+
+# Show that Vector * Vector::Col produces dot product
+a * b.trans
+a.dot(b)
+
+# Show that Vector::Col * Vector produces Matrix
+a.trans * b
+END