rb-gsl 1.15.3.1

data/examples/matrix/complex.rb

@@ -0,0 +1,41 @@
+#!/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 3x3 Matrix::Complex mz
+mz = GSL::Matrix::Complex.alloc(3, 3)
+
+# Set element at row 1, column 2 to 3+5.6i
+mz.set(1, 2, GSL::Complex[3, 5.6])
+
+# Get element at row 1, column 2
+a = mz.get(1, 2)
+
+# Create Matrix::Complex::View of mz
+# starting at row 1, column 1 and
+# spanning 2 rows and 2 columns
+mzv = mz.submatrix(1, 1, 2, 2)
+
+# Create a Vector::Complex::View for row 1 of mz
+row = mz.row(1)
+
+# Create a Vector::Complex::Col::View for column 2 of mz
+col = mz.col(2)
+
+# Iterate through rows of mz
+mz.each_row do |v|
+  p v
+end
+
+# Iterate through columns of mz
+mz.each_col do |v|
+  p v
+end
+END

data/examples/matrix/det.rb

@@ -0,0 +1,29 @@
+#!/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
+# Crete test matrix m
+m = GSL::Matrix[[1, 2, 3, 4, 5, 6, 7, 8 ,0], 3, 3]
+
+# Calculate determinant of m
+m.det
+
+# Calculate trace of m (sum of diagonal elements)
+m.trace
+
+# Convert to Matrix::Complex mz
+mz = m.to_complex
+
+# Calulate determinant of mz
+mz.det
+
+# Calculate trace of mz (sum of diagonal elements)
+mz.trace
+END

data/examples/matrix/diagonal.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 matrix with diagonal given by Range
+GSL::Matrix.diagonal(1..3)
+
+# Create matrix with diagonal given by Array
+GSL::Matrix.diagonal([1, 2, 3])
+
+# Create matrix with diagonal given by GSL::Vector
+GSL::Matrix.diagonal(GSL::Vector.indgen(3,1))
+
+# Create matrix with diagonal given by individual elements
+GSL::Matrix.diagonal(1, 2, 3)
+END

data/examples/matrix/get_all.rb

@@ -0,0 +1,159 @@
+#!/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 Matrix#get or its alias Matrix#[]
+# can be invoked.  For one or two Fixnum arguments or a single two-element
+# Array argument, a single element is returned.  For all other cases,
+# Matrix#get is essentially an alias for Matrix#submatrix.  See
+# examples/matrix/view_all.rb for more examples.
+
+# Create 4x4 test matrix m
+m = GSL::Matrix.indgen(4, 4)
+
+# Matrix#[] with zero args returns a Matrix::View of entire Matrix
+m[]
+
+# Matrix#[] with one Fixnum argument, i, treats the Matrix as a Vector and
+# returns a Matrix::View of the i'th element if i is positive or the
+# (i+size1*size2)'th element if i is negative.
+m[3]
+m[-3]
+
+# Matrix#[Fixnum, Fixnum] returns a Matrix::View of the single element at
+# the specified row and column.
+m[2, 3]
+m[-1, -3]
+
+# Matrix#[[Fixnum, Fixnum]] (note the double square brackets) is treated the
+# same as Matrix#[Fixnum, Fixnum].  This special case exists to allow values
+# returned by Matrix#max_index and Matrix#min_index to be used as indexes.
+m[[2, 3]]
+m[[-1, -3]]
+m.max_index
+m[m.max_index]
+m.min_index
+m[m.min_index]
+
+# When Matrix#[] is called with two arguments, the first specifies which
+# row(s) the view will cover and the second specifies which column(s) the view
+# will cover.  The arguments may be nil (indicating all rows or columns),
+# a Fixnum (indicating a single row or column), or a Range (indicating a range
+# of rows or columns).  The return type is Matrix::View unless exactly one
+# argument is a Fixnum in which case a Vector::View or Vector::Col::View is
+# returned.
+#
+# NOTE: GSL 1.11 (and maybe earlier versions) has a bug that can prevent the
+# exactly-one-Fixnum case from working properly if the Matrix does not have an
+# equal number of rows and columns!!!
+
+# Matrix#[nil, nil] returns a Matrix::View of entire Matrix
+m[nil, nil]
+
+# Matrix#[Range, Range] returns a Matrix::View of the rows and columns
+# specified by the two Ranges.
+m[0...2, 1..-2]
+m[-3..-1, -4...4]
+
+# Matrix#[Fixnum, nil] returns a Vector::View of the entire row specified
+# by the Fixnum argument.  A negative value is treated as counting backwards
+# from the end of the corresponding dimension.  NOTE: GSL 1.11 (and maybe
+# earlier versions) has a bug that prevents this from working if the Matrix has
+# more columns than rows!!!
+m[1, nil]
+m[-2, nil]
+
+# Matrix#[nil, Fixnum] returns a Vector::Col::View of the entire column
+# specified by the Fixnum argument.  A negative value is treated as counting
+# backwards from the end of the corresponding dimension.  NOTE: GSL 1.11 (and
+# maybe earlier versions) has a bug that prevents this from working if the
+# Matrix has more rows than columns!!!
+m[nil, 1]
+m[nil, -2]
+
+# Matrix#[Range,nil] returns a Matrix::View of all columns and the rows
+# specified by the Range argument.  Note that negative begin and/or end values
+# are treated as counting backwards from the end of corresponding dimension.
+m[1...3, nil]
+m[0..-2, nil]
+m[-2..3, nil]
+m[-2..-1, nil]
+
+# Matrix#[nil, Range] returns a Matrix::View of all rows and the columns
+# specified by the Range argument.  Note that negative begin and/or end values
+# are treated as counting backwards from the end of corresponding dimension.
+m[nil, 1...3]
+m[nil, 0..-2]
+m[nil, -2..3]
+m[nil, -2..-1]
+
+# Matrix#[Range, Fixnum] returns a Vector::Col::View of the rows specified
+# by the Range argument of the column specified by the Fixnum argument.  A
+# negative value is treated as counting backwards from the end of the
+# corresponding dimension.  NOTE: GSL 1.11 (and maybe earlier versions) has a
+# bug that prevents this from working if the Matrix has more rows than
+# columns!!!
+m[1...3, 0]
+m[0..-2, 1]
+m[-2..3, -2]
+m[-2..-1, -1]
+
+# Matrix#[Fixnum, Range] returns a Vector::View of the columns specified
+# by the Range argument of the row specified by the Fixnum argument.  A
+# negative value is treated as counting backwards from the end of the
+# corresponding dimension.  NOTE: GSL 1.11 (and maybe earlier versions) has a
+# bug that prevents this from working if the Matrix has more rows than
+# columns!!!
+m[0, 1...3]
+m[1, 0..-2]
+m[-2, -2..3]
+m[-1, -2..-1]
+
+# When Matrix#[] is called with three arguments, the first or last argument
+# must be nil or a Range and the other two arguments must be Fixnums.  The two
+# Fixnums indicate a span whose offset is given by the first Fixnum and whose
+# length is given by the second Fixnum.  If they are the first two arguments,
+# they indicate which rows the returned view will cover.  If they are the last
+# two arguments, they indicate which columns the returned view will cover.  The
+# nil or Range argument indicate what portion of the other dimension will be
+# covered by the returned view (nil means all rows or columns).
+
+# Matrix#[nil, Fixnum, Fixnum] returns a Matrix::View covering all rows of
+# the column span specified by the two Fixnums.
+m[nil, 1, 2]
+m[nil, -2, 2]
+
+# Matrix#[Fixnum, Fixnum, nil] returns a Matrix::View covering all columns
+# of the row span specified by the two Fixnums.
+m[nil, 1, 2]
+m[nil, -2, 2]
+
+# Matrix#[Range, Fixnum, Fixnum] returns a Matrix::View covering Range rows
+# of the column span specified by the two Fixnums.
+m[0...2, -3, 2]
+m[1..-2, 1, 2]
+m[-3..-1, 3, 1]
+m[-4...4, -4, 2]
+
+# Matrix#[Fixnum, Fixnum, Range] returns a Matrix::View covering Range
+# columns of the row span specified by the two Fixnums.
+m[-3, 2, 0...2]
+m[1, 2, 1..-2]
+m[3, 1, -3..-1]
+m[-4, 2, -4...4]
+
+# When Matrix#[] is called with four arguments, all four arguments must be
+# Fixnums.  The first two Fixnums specify the Matrix element that will be the
+# upper left corner of the view (negative values are treated as counting
+# backwrds from the end of the corresponding dimension).  The last two Fixnums
+# specify the number of rows and columns that the view will have.
+m[0, 1, 2, 3]
+m[-2, -3, 2, 1]
+END

data/examples/matrix/hilbert.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 3x3 Hilbert matrix m
+m = GSL::Matrix.hilbert(3)
+
+# Compute inverse of m
+invm = m.inv
+
+# Create inverse of 3x3 Hilbert matrix directly
+invm2 = GSL::Matrix.invhilbert(3)
+
+# Show that both inverse matrices are inverses of m
+m*invm
+m*invm2
+
+# Show that the two inverse matrices are equal
+# to absolute accuracy eps = 1e-10
+invm == invm2
+
+# Show that they may not be exactly equal
+invm - invm2
+END

data/examples/matrix/iterator.rb

@@ -0,0 +1,19 @@
+#!/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 matrix
+m = GSL::Matrix.alloc([1, 2, 3, 4, 5, 6, 7, 8 ,9], 3, 3)
+
+# Iterate through columns
+m.each_col do |v|
+  p v
+end
+END

data/examples/matrix/matrix.rb

@@ -0,0 +1,57 @@
+#!/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 matrix m
+m = GSL::Matrix.alloc([1, 2, 3, 4, 5, 6, 7, 8, 9], 3, 3)
+
+# Set rows of m from Arrays
+m.set([6, 5, 6], [4, 5, 7], [8, 5, 21])
+
+# Set column 1 of m from GSL::Vector
+m.set_col(1, GSL::Vector[12, 3, 55])
+
+# Create transpose of m
+m2 = m.transpose
+
+# Swap rows 1 and 2 of m
+m.swap_rows(1, 2)
+
+# Create Vector::Col::View for column 0 of m
+v = m.col(0)
+
+# Create Vector::View of diagonal of m
+m.diagonal
+
+# Create Array containing diagonal elements of m
+m.diagonal.to_a
+
+# Create another test matrix m
+m = GSL::Matrix.alloc([1, 2, 3], [6, 5, 4], [7, 8, 1])
+
+# Get element at row 1, column 2
+m.get(1, 2)
+
+# Perform LU decomposition of m
+lu, perm, sign = m.LU_decomp
+
+# Create 5x5 zero matrix m5
+m5 = GSL::Matrix.alloc(5, 5)
+
+# Initialize elements of m5
+for i in 0...5 do
+  for j in 0...5 do
+    m5[i, j] = 0.5*(i+0.4)*(j+1.2)
+  end
+end
+
+# Show m5
+m5
+END

data/examples/matrix/minmax.rb

@@ -0,0 +1,53 @@
+#!/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 Matrix
+a = GSL::Matrix.alloc([1, 2, 3, 4, 5, 6, 7, 8, 9], 3, 3)
+
+# 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
+minmax_idx = a.minmax_index
+
+# Use minmax_idx to get minimnum
+a[minmax_idx[0]]
+
+# Use minmax_idx to get maximnum
+a[minmax_idx[1]]
+
+# Show that #isnull returns 0 for non-null Matrix
+a.isnull
+
+# Show that #isnull? returns false for non-null Matrix
+a.isnull?
+
+# Set all elements to zero
+a.set_zero
+
+# Show that #isnull returns 1 for null Matrix
+a.isnull
+
+# Show that #isnull? returns true for null Matrix
+a.isnull?
+END

data/examples/matrix/mul.rb

@@ -0,0 +1,39 @@
+#!/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 3x3 test matrices
+a = GSL::Matrix.alloc([1, 2, 3, 4, 5, 6, 7, 8, 9], 3, 3)
+b = GSL::Matrix.alloc([6, 7, 8], [2, 3, 4], [3, 4, 5])
+
+# Multiply elements of Matrix a by 2 (Matrix a remains unmodifided)
+a * 2
+
+# Multiply elements of Matrix a by 2 (Matrix a remains unmodifided)
+2 * a
+
+# Multiply elements of Matrix a by 2, modifying Matrix a
+a *= 2
+
+# Show a
+a
+
+# Divide elements of Matrix a by 2, modifying Matrix a
+a /= 2
+
+# Show a
+a
+
+# Matrix-multiply Matrix a and Matrix b
+a*b
+
+# Do element-wise multiplication of a and b
+a.mul_elements(b)
+END