gsl 1.12.109 → 1.14.5

data/examples/vector/b.dat

@@ -0,0 +1,4 @@
+5
+6
+7
+8

data/examples/vector/c.dat

@@ -0,0 +1,3 @@
+1 5 6 5
+3 5 6 7
+5 6 7 9

data/examples/vector/collect.rb

@@ -0,0 +1,26 @@
+#!/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 v
+v = GSL::Vector::Int[0..5]
+
+# Create new Vector whose elements are squares of v's elements
+v.collect { |a| a*a }
+
+# Show that v us unmodified
+v
+
+# Square elements of v in-place
+v.collect! { |a| a*a }
+
+# Show that v is modified
+v
+END

data/examples/vector/compare.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 three Vectors: x, y, z
+x = GSL::Vector::Int[1, 2, 3]
+y = GSL::Vector::Int[1, 2, 5]
+z = GSL::Vector::Int[0, 2, 9]
+
+# Test element-wise "==" method
+x.eq(y)
+
+# Test element-wise "!=" method
+x.ne(y)
+
+# Test element-wise ">=" method
+x.ge(y)
+
+# Test element-wise "<" method
+x.lt(z)
+END

data/examples/vector/complex.rb

@@ -0,0 +1,51 @@
+#!/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 Vector::Complex of 5 elements, all 0+0i
+v = GSL::Vector::Complex.alloc(5)
+
+# Set element 2 to 3+4i
+v[2] = [3, 4]
+
+# Show vector
+v
+
+# Show element 2
+v[2]
+
+# Use #map! to modify each element of vector in-place
+i = 0
+v.map! do |elm|
+  i += 1
+  elm += i
+end
+
+# Show vector
+v
+
+# Show element 3
+v[3]
+
+# Set all elements to 2+4.7i
+v.set_all([2, 4.7])
+
+# Create subvector starting at element 1 and spanning 3 elements
+v2 = v.subvector(1, 3)
+
+# Show size of subvector
+v2.size
+
+# Get a Vector::View of the real components of Vector::Complex v
+p v.real
+
+# Convert v to an Array
+v.to_a
+END

data/examples/vector/complex_get_all.rb

@@ -0,0 +1,85 @@
+#!/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::Complex#get or its alias
+# Vector::Complex#[] 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::Complex containing the specified elements, in the specified
+# order, is returned.  For all other cases, Vector::Complex#get is essentially
+# an alias for Vector::Complex#subvector.  See examples/vector/view_all.rb for
+# more examples.
+
+# Create test vector v
+v = GSL::Vector::Complex.indgen(9)
+
+# Vector::Complex#[] with zero args returns a Vector::Complex::View of entire
+# Vector::Complex
+v[]
+
+# Vector::Complex#[] 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::Complex#[] with single Array argument.  Notice the inner pair of
+# brackets!
+v[[1,4,-9]]
+
+# Vector::Complex#[] with a single GSL::Permutation argument.
+p = GSL::Permutation.calloc(4).reverse
+v[p]
+
+# Vector::Complex#[] with one Range argument returns a Vector::Complex::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::Complex#[] 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::Complex#[] 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::Complex#[] 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/complex_set_all.rb

@@ -0,0 +1,131 @@
+#!/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::Complex#set or its alias
+# Vector::Complex#[]= can be invoked.  For a single argument, this is
+# equivalent to Vector::Complex#set_all.  For two arguments with the first
+# being a Fixnum i, this sets the i'th element (or the (size-i)'th element to
+# the complex value derived from the second argument.  The second argument may
+# be a Fixnum, Bignum, Float or two element Array.  For the Array case, the
+# first element is the real component and the second element is the imaginary
+# component.  A nil component leave that component unchanged.  All other forms
+# treat all but the last argument as with Vector::Complex#subvector and set the
+# specified elements based on the last argument, which can be a Vector::Complex
+# (or Vector::Complex::View), Array, Range, Fixnum, Bignum, or Float.
+# Vector::Complex, Array, and Range rvalues must have the same number of
+# elements as the specified subvector.  For a Fixnum, Bignum, or Float rvalue,
+# all elements of the subvector are set to that value.
+#
+# Note the different return values of Vector::Complex#set and
+# Vector::Complex#[]=.  Vector::Complex#set return self, but Vector::Complex[]=
+# 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::Complex 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/complex_view_all.rb for additional examples of how to
+# specify subvectors.
+
+# Create test vector v
+v = GSL::Vector::Complex.indgen(9)
+
+# Vector::Complex#set and Vector::Complex#[]= with one arg sets all elements
+v.set(1.2)
+v[] = 3.4
+v
+
+# Vector::Complex#[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
+v[-8] = [nil, 1.0] # Set imaginary component only
+v[-8]
+v[-8] = [nil, 0.0] # Set imaginary component only
+v[-8]
+
+# Specifying subvector using Range with various rvalue types
+v[1..4] = GSL::Vector::Complex[[2,3],[5,7],[11,13],[17,19]]
+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 Float
+v
+
+# Specifying subvector using Range and stride with various rvalue types
+v[0..4, 2] = GSL::Vector::Complex[[2,3],[5,7],[11,13]]
+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 Float
+v
+
+# Specifying subvector using two Fixnums (offset, length) with various rvalue
+# types
+v[2, 4] = GSL::Vector::Complex[[2,3],[5,7],[11,13],[17,19]]
+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 Float
+v
+
+# Specifying subvector using three Fixnum arguments (offset, stride, length)
+# with various rvalue types
+v[1, 2, 3] = GSL::Vector::Complex[[2,3],[5,7],[11,13]]
+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 Float
+v
+
+# Copying part of a Vector::Complex to another part of the same Vector::Complex 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/complex_view_all.rb

@@ -0,0 +1,77 @@
+#!/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 Vector::Complex::Complex::View can
+# be created using Vector::Complex#subvector or its alias Vector::Complex#view.
+# Note that Vector::Complex#get or, more commonly, its alias Vector::Complex#[]
+# can also be used to create a Vector::Complex::View.  See
+# examples/vector/complex_get_all.rb for more examples.
+
+# Create test vector v
+v = GSL::Vector::Complex.indgen(9)
+
+# Vector::Complex#view with zero args returns a Vector::Complex::View of entire
+# Vector::Complex.
+v.view
+
+# Vector::Complex#view with one Fixnum argument, i, returns a
+# Vector::Complex::View of the first i'th elements if i is positive or the last
+# i'th elements if i is negative.
+v.view(3)
+v.view(-3)
+
+# Vector::Complex#view with one Range argument returns a Vector::Complex::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.view(1..4)
+v.view(4..1)
+v.view(1...4)
+v.view(4...1)
+
+v.view(4..-2)
+v.view(-2..4)
+v.view(4...-2)
+v.view(-2...4)
+
+v.view(-4..8)
+v.view(8..-4)
+v.view(-4...8)
+v.view(8...-4)
+
+v.view(-5..-2)
+v.view(-2..-5)
+v.view(-5...-2)
+v.view(-2...-5)
+
+# Vector::Complex#view with a Range argument and a Fixnum argument is like a
+# single Range argument, but with a stride given by the Fixnum argument.
+v.view(1..7, 3)
+v.view(7..1, 3)
+v.view(1...7, 3)
+v.view(7...1, 3)
+
+# Vector::Complex#view 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.view(2, 4)
+v.view(4, 2)
+v.view(-4, 2)
+v.view(-2, -4)
+
+# Vector::Complex#view 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.view(1, 2, 3)
+v.view(1, -2, -3)
+v.view(-1, -2, 3)
+v.view(-1, 2, -3)
+END

data/examples/vector/connect.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 three test Vectors
+v1 = GSL::Vector[1..2]
+v2 = GSL::Vector[3..4]
+v3 = GSL::Vector[5..7]
+
+# Connect them using GSL::Vector#connect
+v1.connect(v2, v3)
+
+# Connect them using GSL::Vector.connect
+GSL::Vector.connect(v1, v2, v3)
+END

data/examples/vector/decimate.rb

@@ -0,0 +1,38 @@
+#!/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
+# Setup constants
+N = 1000
+DECIMATE1 = 10
+DECIMATE2 = 100
+
+# Setup random number generator
+r = GSL::Rng.alloc
+
+# Create Vector of x values
+x0 = GSL::Vector.linspace(0, 20, N)
+
+# Data: Bessel function + noise
+y0 = GSL::Sf::bessel_J0(x0) + GSL::Ran::gaussian(r, 0.1, N)
+
+# Decimate y0 by DECIMATE1
+y1 = y0.decimate(DECIMATE1)
+
+# Decimate y0 by DECIMATE2
+y2 = y0.decimate(DECIMATE2)
+
+# Create Vectors of decimated x values
+x1 = GSL::Vector.linspace(0, 20, N/DECIMATE1)
+x2 = GSL::Vector.linspace(0, 20, N/DECIMATE2)
+
+# y1 and y2 are shifted vertically for visual purpose
+GSL::graph([x0, y0], [x1, y1-1], [x2, y2-2])  
+END