rb-gsl 1.15.3.1

data/examples/vector/narray.rb

@@ -0,0 +1,46 @@
+#!/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 NMatrix m
+m = NMatrix[[0, 1.2, 1],[1.5, 0, 2]]
+
+# Convert NMatrix m to Vector gv
+gv = m.to_gv
+
+# Convert Vector gv to NArray m2
+m2 = gv.to_na
+m2.class
+
+# Create GSL::Vector v
+v = GSL::Vector.alloc(1..4)
+
+# Convert v to NArray na
+na = v.to_na
+na.class
+
+# Convert na back to Vector
+v2 = na.to_gv
+
+# Create new Vector copy of na
+v3 = GSL::Vector.alloc(na)
+
+# Create Vector::View of na
+v4 = na.to_gv_view
+
+# Set element of Vector::View
+v4[2] = 123
+
+# Show that na was modified
+na
+
+# Show that v3 was not modified
+v3
+END

data/examples/vector/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 test Vector v
+v = GSL::Vector.alloc(4)
+
+# Read data into Vector v from binary file a.dat using #fread
+v.fread("a.dat")
+
+# Show v
+v
+
+# Create another test Vector
+v2 = GSL::Vector.alloc(4)
+
+# Read data into Vector v2 from text file b.dat using #fscanf
+v2.fscanf("b.dat")
+
+# Show v2
+v2
+END

data/examples/vector/set.rb

@@ -0,0 +1,35 @@
+#!/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.alloc(1, 2, 3, 4, 5)
+
+# Show third element
+v[3]
+
+# Set all elements to 9
+v.set_all(9)
+
+# Set all elements to 0
+v.set_zero
+
+# Set all elements to 3
+v[] = 3
+
+# Show v
+v
+
+# Set all elements to 0, except element 3 which is set to 1
+v.set_basis(3)
+
+# Set element 2 to 5.0
+v.set(2, 5)
+END

data/examples/vector/set_all.rb

@@ -0,0 +1,121 @@
+#!/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 Vector#set or its alias Vector#[]=
+# can be invoked.  For a single argument, this is equivalent to Vector#set_all.
+# For two arguments with the first a Fixnum i, this sets the i'th element (or
+# the (size-i)'th element to the value of the second argument.  All other forms
+# treat all but the last argument as with Vector#subvector and set the
+# specified elements based on the last argument, which can be a Vector (or
+# Vector::View), an Array, a Range, or a Numeric.  Vector, Array, and Range
+# rvalues must have the same number of elements as the specified subvector.
+# For a Numeric rvalue, all elements of the subvector are set to that value.
+#
+# Note the different return values of Vector#set and Vector#[]=.  Vector#set
+# return self, but Vector[]= return the value to the right of the = sign.  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 #[]=.
+#
+# Also be careful is setting part of a Vector from another part of the same
+# vector.  The GSL method that performs this operation uses memcpy, which does
+# not handle overlapping memory regions in a well defined way.  See the last
+# two examples.
+#
+# See examples/vector/view_all.rb for additional examples of how to specify
+# subvectors.
+
+# Create test vector v
+v = GSL::Vector.indgen(9)
+
+# Vector#set and Vector#[]= with one arg sets all elements
+v.set(1.2)
+v[] = 3.4
+v
+
+# Vector#[i]= Numeric sets the i'th element if i is
+# positive or the (size+i)'th element if i is negative.
+v[3] = 5.6
+v[-8] = 7.8
+v
+
+# Specifying subvector using Range with various rvalue types
+v[1..4] = GSL::Vector[2, 3, 5, 7] # rvalue is Vector
+v
+
+v[1..4] = [11, 13, 17, 19] # rvalue is Array
+v
+
+v[1..4] = 24..27 # rvalue is Range
+v
+
+v[1..4] = 1.0 # rvalue is Numeric
+v
+
+# Specifying subvector using Range and stride with various rvalue types
+v[0..4, 2] = GSL::Vector[2, 3, 5] # rvalue is Vector
+v
+
+v[0..4, 2] = [7, 11, 13] # rvalue is Array
+v
+
+v[0..4, 2] = 8..10 # rvalue is Range
+v
+
+v[0..4, 2] = 1.0 # rvalue is Numeric
+v
+
+# Specifying subvector using two Fixnums (offset, length) with various rvalue
+# types
+v[2, 4] = GSL::Vector[2, 3, 5, 7] # rvalue is Vector
+v
+
+v[2, 4] = [11, 13, 17, 19] # rvalue is Array
+v
+
+v[2, 4] = 24..27 # rvalue is Range
+v
+
+v[2, 4] = 1.0 # rvalue is Numeric
+v
+
+# Specifying subvector using three Fixnum arguments (offset, stride, length)
+# with various rvalue types
+v[1, 2, 3] = GSL::Vector[2, 3, 5] # rvalue is Vector
+v
+
+v[1, 2, 3] = [7, 11, 13] # rvalue is Array
+v
+
+v[1, 2, 3] = 8..10 # rvalue is Range
+v
+
+v[1, 2, 3] = 1.0 # rvalue is Numeric
+v
+
+# Copying part of a Vector to another part of the same Vector can potentially
+# be problematic if the regions overlap.
+v.indgen!
+v[0, 3] = v[2, 3]
+v
+
+v.indgen!
+v[2, 3] = v[0, 3]
+v
+
+# But it's OK if the regions do not overlap
+v.indgen!
+v[0, 3] = v[3, 3]
+v
+
+v.indgen!
+v[3, 3] = v[0, 3]
+v
+END

data/examples/vector/smpv.dat

@@ -0,0 +1,15 @@
+1
+3
+5
+75
+6
+5
+568
+35
+578
+54
+758
+786
+23
+34524
+13

data/examples/vector/test.rb

@@ -0,0 +1,43 @@
+#!/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 one Vector and two Vector::Ints
+x = GSL::Vector[1, 2, 3]
+y = GSL::Vector::Int[1, 0, 5]
+a = GSL::Vector::Int[0, 0, 0]
+
+# Call #any? on them
+x.any?
+y.any?
+a.any?
+
+# Call #all? on them
+x.all?
+y.all?
+a.all?
+
+# Call #none? on them
+x.none?
+y.none?
+a.none?
+
+# Call x.any? with blocks
+x.any? { |val| val > 5 }
+x.any? { |val| val > 2 }
+
+# Call x.all? with blocks
+x.all? { |val| val >= 1 }
+x.all? { |val| val >= 2 }
+
+# Call x.none? with blocks
+x.none? { |val| val == 1 }
+x.none? { |val| val == 5 }
+END

data/examples/vector/test_gslblock.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+# Turn on warnings
+$-w = true
+
+# This script is written by Cameron McBride.
+# Thank you Cameron!
+
+#gem 'gsl', '=1.10.3'
+require 'irb/xmp'
+require 'gsl'
+puts "Using rb-gsl #{GSL::RB_GSL_VERSION}"
+
+# Seed random number generator for repeatable results
+srand(?r-?b+?g-?s-?l)
+
+# The creation of the test Vector below can be replaced with any of these lines
+# to show the behavior with GSL::Block, GSL::Vector::Int, and
+# GSL::Vector::Int::Block.  Note that the block objects should NOT be created
+# using "v = GSL::Vector[0..9].block" because the Vector object will be subject
+# to garbage collection which will free the memory that the Block object points
+# to.  See the BUGS file for more information.
+#
+# vv = GSL::Vector[0..9]; v = vv.block
+# v = GSL::Vector::Int[0..9]
+# vv = GSL::Vector::Int[0..9]; v = vv.block
+
+# 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
+v = GSL::Vector[0..9]
+
+# Create mask
+mask = (v > 2)
+
+# Show mask.where with no block
+mask.where
+
+# Show mask.where with "true" block
+mask.where { true }
+
+# Show mask.where with "false" block
+# NB: Returns nil, not empty object!
+mask.where { false }
+
+# Show mask.where with no block
+mask.where2
+
+# Show mask.where with "true" block
+mask.where2 { true  }
+
+# Show mask.where with "false" block
+mask.where2 { false }
+
+# Show mask.where with random block
+mask.where2 { rand > 0.5 }
+END

data/examples/vector/vector.rb

@@ -0,0 +1,110 @@
+#!/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 with 15 elements initialized to 0.0
+v = GSL::Vector::alloc(15)
+
+# Set elements of v from file smpv.dat
+File.open("smpv.dat") do |f|
+  v.fscanf(f)
+end
+
+# Show v
+v
+
+# Create another test vector with three elements
+# initialized to 10.0, 1.0, and 3.0.
+v2 = GSL::Vector.alloc(10, 1, 3)
+END
+
+__END__
+
+# TODO Remove examples below that are duplicated elsewhere
+# TODO Include examples below that are not duplicated elsewhere
+v = GSL::Vector::alloc([9, 1, 2, 3, 12, 6, 0.1, 0.56, 5, 7, 2])
+v.print
+p v.size
+v2 = GSL::Vector::alloc(11)
+v2.set(1, 123)
+p v2.to_a
+
+v = GSL::Vector::alloc([1, 2, 3, 4, 5])
+v.print
+a = v.to_a
+p a
+a[2] = 12.0
+v2 = a.to_gv
+v2.print
+__END__
+
+p = v.sort_index
+p p.to_a
+
+v2 = GSL::Vector::alloc([5, 6, 7])
+
+v3 = v2.scale!(2)
+v3.print
+v2.print
+
+p v3.minmax
+
+p v3.max_index
+p v3.min_index
+p v3.minmax_index
+
+a = [1, 2, 3]
+v = a.to_gv
+p v.to_a
+
+__END__
+
+v3 = v * v2
+v3.print
+
+v.print
+
+v.mul!(v2)
+v.print
+
+__END__
+
+v = GSL::Vector::alloc(10)
+for i in 1...10 do
+  v.set(i, i.to_f)	
+end	
+v.print
+
+v.swap_elements(3, 5)
+v.print
+
+v.reverse.print
+
+__END__
+
+v2 = v.subvector(2, 3)
+v2.print
+
+v3 = v.subvector_with_stride(2, 2, 3)
+v3.print
+
+v3.set([2, 3, 9])
+v3.print
+
+v4 = GSL::Vector::alloc([1, 2, 3, 5])
+v4.print
+
+a = v4.to_a
+p a
+
+__END__
+v.each do |x|
+  p x
+end