GSL::Vector class

Class methods

GSL::Vector.new(ary)

GSL::Vector.new(size)

GSL::Vector.new(n, xmin, xmax)

These methods create a GSL::Vector object. With an integer, a vector object is initialized in a given size,

require('gsl')
v = Vector.new(10)         ( or use 'alloc' )

Vector elements will be set with the 'set' method.

One can create a vector by giving an array, as

v = Vector.new([1, 2, 3])

The vector created has the same length of the given array. If a NArray object is given, a Vector with newly allocated data is created. The third form is by giving three arguments. the first n specifies the number of elements of the vector, and the range xmin, xmax is divided uniformly into n sub-intervals.

ex:

na = NArray[1.0, 2, 3, 4, 5]
p na                <----- NArray.float(5): 
                           [ 1.0, 2.0, 3.0, 4.0, 5.0]
v = Vector.new(na)  
p v                 <----- [ 1.000e+00 2.000e+00 3.000e+00 4.000e+00 5.000e+00]
                           #<GSL::Vector:0x367ff4>

GSL::Vector.GSL::Vector.calloc(size)

This method also creates a vector object, and initializes all the elements to zero.

Methods

GSL::Vector#get(i)

This returns the i-th element of the vector self. The [] method is also available.

ex:

p v.get(2) p v[2]

GSL::Vector#set(i, val)

This method sets the i-th element of the vector self to val.

v.set(2, 3.5)      # v[2] = 3.5

GSL::Vector#set_all(x)

This method sets all the elements of the vector to the value x.

v.set_all(3.5)

GSL::Vector#set_zero

This method sets all the elements of the vector to zero.

GSL::Vector#set_basis!(i)

This method makes a basis vector by setting all the elements of the vector to zero except for the i-th element, which is set to one. For a vector v of the size 10, the method

v.set_basis!(4)

sets the vector self to a basis vector [0, 0, 0, 0, 1, 0, 0, 0, 0, 0]. Note that the vector self is modified.

GSL::Vector#set_basis(i)

This method returns a basis vector by setting all the elements of the vector to zero except for the i-th element which is set to one. For a vector v of the size 10, the method

vb = v.set_basis(4)

creates a new vector self with elements [0, 0, 0, 0, 1, 0, 0, 0, 0, 0]. The vector self is not changed.

GSL::Vector#each

Iterator for each vector element.

v.each do |x|
  p x
end

GSL::Vector#each_index

IO

GSL::Vector#print: Show all the elements of the vector in %4.3e format.
GSL::Vector#fprintf(io, format = "%e")
GSL::Vector#fprintf(filename, format = "%e")
GSL::Vector#fscanf(io)
GSL::Vector#fscanf(filename)
GSL::Vector#fwrite(io)
GSL::Vector#fwrite(filename)
GSL::Vector#fread(io)
GSL::Vector#fread(filename)
GSL::Vector#clone: This method creates a new vector of the same elements.
GSL::Vector#swap_elements(i, j): This method exchanges the i-th and j-th elements of the vector in-place.
GSL::Vector#reverse: This method reverses the order of the elements of the vector.

Vector views

The GSL::Vector::View class is defined to be used as "references" to vectors. The Vector::View class is a subclass of the class Vector, so an instance of the View class created by slicing a Vector object can be used same as a Vector object. The View object shares the data with the original vector i.e. modifications in the elements of the View object affect to the original vector.

GSL::Vector#subvector(offset, n)

GSL::Vector#subvector(n)

GSL::Vector#subvector

This method creates a Vector::View object slicing n elements of the vector self from the offset offset. If called with one argument n, offset is set to 0. With no arguments, a view is created with the same length of the original vector.

ex:

#!/usr/bin/env ruby
require("gsl")

v = Vector.new([1, 2, 3, 4, 5, 6])
view = v.subvector(1, 4)
p view.class         <----- GSL::Vector::View
view.print           <----- [ 2.000e+00 3.000e+00 4.000e+00 5.000e+00 ]

view[2] = 99
view.print           <----- [ 2.000e+00 3.000e+00 9.900e+01 5.000e+00 ]
v.print              <----- [ 1.000e+00 2.000e+00 3.000e+00 9.900e+01 5.000e+00 6.000e+00 ]

GSL::Vector#subvector_with_stride(offset, n, stride)

GSL::Vectir#matrix_view(n1, n2)

This creates a Matrix::View object from the vector self. It enables to use the vector as a Matrix object.

ex:

v2 = Vector.new([1, 2, 3, 4, 5, 6, 7, 8, 9])
mview = v2.matrix_view(3, 3)
p mview.class            <----- GSL::Matrix::View
mview.print              <----- [ 1.000e+00 2.000e+00 3.000e+00 
                                  4.000e+00 5.000e+00 6.000e+00 
                                  7.000e+00 8.000e+00 9.000e+00 ]
mview.set(2, 1, 99.9)
mview.print              <----- [ 1.000e+00 2.000e+00 3.000e+00 
                                  4.000e+00 5.000e+00 6.000e+00 
                                  7.000e+00 9.990e+01 9.000e+00 ]
v2.print                 
    <----- [ 1.000e+00 2.000e+00 3.000e+00 4.000e+00 5.000e+00 6.000e+00 7.000e+00 9.990e+01 9.000e+00 ]

Vector operations

GSL::Vector#add!(b): This method adds the elements of vector b to the elements of vector self. The vector self is modified in place. The two vectors must have the same length.
GSL::Vector#add(b): This method adds the elements of vector b to the elements of the vector self, and returns a new vector. The vector self is not changed.
GSL::Vector#sub!(b): This method subtracts the elements of vector b from the elements of vector self. The two vectors must have the same length. The vector self is modified in place.
GSL::Vector#sub(b): Same as GSL::Vector#sub!(b), but not modifies the vector itself, and returns a new vector.
GSL::Vector#mul!(b): This method multiplies the elements of vector self by the elements of vector b. The two vectors must have the same length. The vector self is modified.
GSL::Vector#mul(b): Same as GSL::Vector#mul!(b), but not modifies the vector, and returns a new vector.
GSL::Vector#div!(b): This method divides the elements of vector self by the elements of vector b. The two vectors must have the same length. The vector self is modified.
GSL::Vector#div(b): Same as GSL::Vector#div!(b), but not modifies the vector self, and returns a new vector.
GSL::Vector#scale!(x)
GSL::Vector#scale(x): This method multiplies the elements of vector self by the constant factor x.
GSL::Vector#add_constant!(x)
GSL::Vector#add_constant(x): This method adds the constant value x to the elements of the vector self.
GSL::Vector#reverse
GSL::Vector#swap_elements
GSL::Vector#clone: This creates a copy of the vector self.

Finding maximum and minimum elements of vectors

GSL::Vector#max: This method returns the maximum value in the vector.
GSL::Vector#min: This method returns the minimum value in the vector.
GSL::Vector#minmax: This method returns an array of two elements, the minimum and the maximum values in the vector self.
GSL::Vector#max_index: This method returns the index of the maximum value in the vector. When there are several equal maximum elements then the lowest index is returned.
GSL::Vector#min_index: This method returns the index of the minimum value in the vector. When there are several equal minimum elements then the lowest index is returned.
GSL::Vector#minmax_index: This method returns an array of two elements which has the indices of the minimum and the maximum values in the vector self.

NArray

GSL::Vector#to_a

This method converts the vector into a Ruby array. A Ruby array also can be converted into a GSL::Vector object with the to_gv method. For example,

v = GSL::Vector.alloc([1, 2, 3, 4, 5])
v.print      -> 1.0000e+00 2.0000e+00 3.0000e+00 4.0000e+00 5.0000e+00
a = v.to_a   -> GSL::Vector to an array
p a          -> [1.0, 2.0, 3.0, 4.0, 5.0]
a[2] = 12.0
v2 = a.to_gv  -> a new GSL::Vector object
v2.print     -> 1.0000e+00 2.0000e+00 1.2000e+01 4.0000e+00 5.0000e+00

GSL::Vector#to_na

The Vector object self is converted into an NArray object. The array data are copied to newly allocated memory.

GSL::Vector.to_gv(na)

GSL::Vector.to_gslv(na)

A GSL::Vector::View object is created. The array data of na are not copied, thus any modifications to the View object affect on the original NArray object. The View object can be used as a reference to the NArray object.

back