rb-gsl 1.15.3.1

data/examples/matrix/rand.rb

@@ -0,0 +1,20 @@
+#!/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
+# Initialize random number generator with fixed seed for repeatable sequence
+r = GSL::Rng.alloc(GSL::Rng::MT19937, ?r-?b+?g-?s-?l)
+
+# Create 3x3 matrix initialized with numbers from uniform distribution
+u = GSL::Matrix.rand(3, 3, r)
+
+# Create 3x3 matrix initialized with numbers from normal distribution
+n = GSL::Matrix.randn(3, 3, r)
+END

data/examples/matrix/read.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
+# Create a 2x2 test Matrix m
+m = GSL::Matrix.alloc(2, 2)
+
+# Read data into Matrix m from binary file a.dat using #fread
+m.fread("a.dat")
+
+# Show m
+m
+
+# Create a 2x2 test Matrix m2
+m2 = GSL::Matrix.alloc(2, 2)
+
+# Read data into Matrix m2 from text file b.dat using #fscanf
+m2.fscanf("b.dat")
+
+# Show m2
+m2
+END

data/examples/matrix/rowcol.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 3x3 test Matrix a
+a = GSL::Matrix.alloc([1, 2, 3, 4, 5, 6, 7, 8, 9], 3, 3)
+
+# Create Vector initialized from row 0 of Matrix a
+b = a.get_row(0)
+
+# Create Vector::Col for column 2 of Matrix a
+c = a.get_col(2)
+
+# Set column 2 of Matrix a from Vector from row 0
+a.set_col(2, b)
+
+# Set row 0 of Matrix a from Vector::Col from column 2
+a.set_row(0, c)
+
+# Create new Matrix from a with rows 1 and 2 swapped
+a.swap_rows(1, 2)
+
+# Show that Matrix a remains unmodified
+a
+
+# Swap columns 1 and 2 of Matrix a in-place
+a.swap_cols!(1, 2)
+
+# Show that Matrix a is modified
+a
+
+# Create new Matrix that is transpose of Matrix a
+atrans = a.transpose
+
+# Transpose Matrix a in-place
+a.transpose!
+
+# Transpose Matrix a in-place again
+a.transpose!
+END

data/examples/matrix/set.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 a 3x3 matrix
+m = GSL::Matrix.alloc([1, 2, 3, 4, 5, 6, 7, 8, 9], 3, 3)
+
+# Create a 3x4 matrix
+m = GSL::Matrix.indgen(3, 4)
+
+# Set element at row 1, column 2 to 99.9
+m[1,2] = 99.9
+
+# Show matrix
+m
+
+# Set all elements to 5 using #set_all
+m.set_all(5)
+
+# Set all elements to 4.3 using #set
+m.set(4.3)
+
+# Set all elements to 2 using #[]
+m[] = 2
+
+# Show matrix
+m
+
+# Set all elements to 0
+m.set_zero
+
+# Set matrix to identity matrix
+m.set_identity
+END

data/examples/matrix/set_all.rb

@@ -0,0 +1,100 @@
+#!/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 some of the ways that Matrix#set or its alias Matrix#[]=
+# can be invoked. First, create test matrix m...
+
+m = GSL::Matrix[3,4]
+
+# For a single Array argument, i.e. m.set([row0,row1,...]) or
+# m[]=[row0,row1,...], the Array's elements are taken as row contents.  Each
+# given row must have exactly the same number of elements as the Matrix has
+# columns, but the number of rows given need not match the Matrix's row count.
+# Extra given rows are ignored, while Matrix rows beyond those given are not
+# affected.
+
+m[] = [[1,2,3,4],[5,6,7,8],[9,8,7,6]]
+
+m
+
+# Note the different return values of Matrix#set and Matrix#[]=.  Matrix#set
+# return self (see below), but Matrix[]= returns the value to the right of the
+# = sign (see above).  This must be standard Ruby behavior since the underlying
+# code returns the same value to Ruby regardless of whether it is invoked as
+# #set or #[]=.
+
+m.set([[9,8,7,6],[5,4,3,2],[1,0,1,2]])
+
+# For a single non-Array argument, Matrix#set and Matrix#[] are equivalent to
+# Matrix#set_all (other than the difference in the return value of Matrix#[] as
+# noted above).
+
+m.set(1.2)             # could also use:  m[] = 1.2
+
+# For two arguments with the first being an Array and the second a non-Array,
+# i.e. m.set([i,j], x) or m[[i,j]]=x (note the double square brackets), the
+# first two elements of the Array must be Fixnums which specify the row and
+# column of the element that will be set to the value of the second (non-Array)
+# argument.  This special case exists to allow values returned by
+# Matrix#max_index and Matrix#min_index to be used as indexes.
+
+m.indgen!
+
+m[m.max_index] = 100
+
+m[m.min_index] = -100
+
+m
+
+# For three arguments with the first two being Fixnums i and j, this sets
+# element (i,j) to the value of the last argument.
+
+m[1,2] = 50; m[-2,-3] = -50; m
+
+# For multiple arguments with the first two being Arrays, i.e.
+# m.set(row0,row1,...), this behaves as if the rows were given in a single
+# Array (see the first case above).
+
+m.set([1,2,3,4], [5,6,7,8], [9,8,7,6])
+
+# All other forms treat all but the last argument as with Matrix#submatrix and
+# set the specified elements based on the last argument, which can be a Matrix
+# (or Matrix::View), an Array (of Numerics or Arrays of Numerics), a Range, or
+# a Numeric.  Matrix, Array, and Range rvalues must have the same number of
+# elements as the specified submatrix.  For a Numeric rvalue, all elements of
+# the submatrix are set to that value.
+#
+# See examples/matrix/view_all.rb for additional examples of how to specify
+# submatrices.
+
+m[nil,1] = 0; m
+
+m[1,nil] = 1; m
+
+m[1..2,1..3] = 1..6; m
+
+# Also be careful when setting part of a Matrix from another part of the same
+# Matrix.  The GSL method that performs this operation uses memcpy, which does
+# not handle overlapping memory regions in a well defined way.
+
+m.indgen!
+
+# This is faster but has problems with overlap
+m[1..2,1..2] = m[0..1,0..1]; m
+
+n = GSL::Matrix[3,4].indgen!
+
+# Converting right hand side to Array avoids the problem, but is slower
+n[1..2,1..2] = n[0..1,0..1].to_a; n
+
+# See the difference at element [2,2]
+n-m
+END

data/examples/matrix/view.rb

@@ -0,0 +1,32 @@
+#!/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 a 3x3 matrix m
+m = GSL::Matrix.alloc([1, 2, 3, 4, 5, 6, 7, 8, 9], 3, 3)
+
+# Get Vector::View for row 1 of Matrix m
+m.row(1)
+
+# Get Vector::Col::View for column 0 of Matrix m
+m.col(0)
+
+# Get Vector::View for diagonal of Matrix m
+m.diagonal
+
+# Get Vector::View for subdiagonal 1 of Matrix m
+m.subdiagonal(1)
+
+# Get Vector::View for subdiagonal 0 of Matrix m
+m.subdiagonal(0)
+
+# Get Vector::View for superdiagonal 1 of Matrix m
+m.superdiagonal(1)
+END

data/examples/matrix/view_all.rb

@@ -0,0 +1,148 @@
+#!/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 a Matrix::View can be created using
+# Matrix#submatrix or its alias Matrix#view.  Note that Matrix#get or, more
+# commonly, its alias Matrix#[] can also be used to create a Matrix::View.  See
+# examples/matrix/get_all.rb for more examples.
+
+# Create 4x4 test matrix m
+m = GSL::Matrix.indgen(4, 4)
+
+# Matrix#view with zero args returns a Matrix::View of entire Matrix
+m.view
+
+# Matrix#view 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.view(3)
+m.view(-3)
+
+# When Matrix#view 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#view(nil, nil) returns a Matrix::View of entire Matrix
+m.view(nil, nil)
+
+# Matrix#view(Fixnum, Fixnum) returns a Matrix::View of the single element at
+# the specified row and column.
+m.view(2, 3)
+m.view(-1, -3)
+
+# Matrix#view(Range, Range) returns a Matrix::View of the rows and columns
+# specified by the two Ranges.
+m.view(0...2, 1..-2)
+m.view(-3..-1, -4...4)
+
+# Matrix#view(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.view(1, nil)
+m.view(-2, nil)
+
+# Matrix#view(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.view(nil, 1)
+m.view(nil, -2)
+
+# Matrix#view(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.view(1...3, nil)
+m.view(0..-2, nil)
+m.view(-2..3, nil)
+m.view(-2..-1, nil)
+
+# Matrix#view(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.view(nil, 1...3)
+m.view(nil, 0..-2)
+m.view(nil, -2..3)
+m.view(nil, -2..-1)
+
+# Matrix#view(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.view(1...3, 0)
+m.view(0..-2, 1)
+m.view(-2..3, -2)
+m.view(-2..-1, -1)
+
+# Matrix#view(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.view(0, 1...3)
+m.view(1, 0..-2)
+m.view(-2, -2..3)
+m.view(-1, -2..-1)
+
+# When Matrix#view 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#view(nil, Fixnum, Fixnum) returns a Matrix::View covering all rows of
+# the column span specified by the two Fixnums.
+m.view(nil, 1, 2)
+m.view(nil, -2, 2)
+
+# Matrix#view(Fixnum, Fixnum, nil) returns a Matrix::View covering all columns
+# of the row span specified by the two Fixnums.
+m.view(nil, 1, 2)
+m.view(nil, -2, 2)
+
+# Matrix#view(Range, Fixnum, Fixnum) returns a Matrix::View covering Range rows
+# of the column span specified by the two Fixnums.
+m.view(0...2, -3, 2)
+m.view(1..-2, 1, 2)
+m.view(-3..-1, 3, 1)
+m.view(-4...4, -4, 2)
+
+# Matrix#view(Fixnum, Fixnum, Range) returns a Matrix::View covering Range
+# columns of the row span specified by the two Fixnums.
+m.view(-3, 2, 0...2)
+m.view(1, 2, 1..-2)
+m.view(3, 1, -3..-1)
+m.view(-4, 2, -4...4)
+
+# When Matrix#view 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.view(0, 1, 2, 3)
+m.view(-2, -3, 2, 1)
+END

data/examples/matrix/write.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 Matrix
+m = GSL::Matrix.alloc([1, 2], [3, 4])
+
+# Write Matrix in binary format to file a.dat
+m.fwrite("a.dat")
+
+# Create another test Matrix
+m2 = GSL::Matrix.alloc([5, 6], [7, 8])
+
+# Write Matrix in text format to file b.dat
+m2.fprintf("b.dat")
+END