GSL::Vector.alloc(ary)
GSL::Vector.new(ary)
GSL::Vector.new(range)
GSL::Vector.new(size)
GSL::Vector.new(n, [xmin, xmax])
GSL::Vector.new(elm0, elm1, ....)
These methods create a GSL::Vector
object. This example
initializes a vector of length 10,
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])
or with a range object,
v = Vector.new(1..3)
GSL::Vector.GSL::Vector.calloc(size)
If a NArray
object is given, a newly allocated vector is created.
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 2 3 4 5 ] #<GSL::Vector:0x367ff4>
In Ruby/GSL, vector lendth is limited within the range of Fixnum. For 32-bit CPU, the maximum of vector length is 2^30 ~ 1e9.
GSL::Vector#get(i)
GSL::Vector#set(i, val)
This method sets the i-th element of the vector self to val.
ex) v.set(2, 3.5) # v[2] = 3.5
GSL::Vector#set_all(x)
GSL::Vector#set_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]. 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, used as
v.each do |x| p x end
GSL::Vector#each_index
GSL::Vector#print
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
GSL::Vector#swap_elements(i, j)
GSL::Vector#reverse
GSL::Vector#reverse!
The GSL::Vector::View
class is defined to be used as "references" to
the vectors. Since the Vector::View
class is a subclass of the class Vector
,
an instance of the View
class created by slicing a Vector
object
can be used same as the original vector. The
View
object shares the data with the original vector, i.e. changes
in the elements of the View
object affect to the original.
GSL::Vector#subvector(offset, n)
GSL::Vector#subvector(n)
GSL::Vector#subvector
Vector::View
object slicing n elements
of the vector self from the offset offset. If called with only 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 3 4 5 ] view[2] = 99 view.print <----- [ 2 3 99 5 ] v.print <----- [ 1 2 3 99 5 6 ]
GSL::Vector#subvector_with_stride(offset, n, stride)
GSL::Vectir#matrix_view(n1, n2)
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 2 3 4 5 6 7 8 9 ] mview.set(2, 1, 99.9) mview.print <----- [ 1 2 3 4 5 6 7 99.9 9 ] v2.print <----- [ 1 2 3 4 5 6 7 99.9 9 ]
GSL::Vector#trans
GSL::Vector#transpose
GSL::Vector#col
GSL::Vector#row
GSL::Vector#add!(b)
GSL::Vector#+=(b)
GSL::Vector#add(b)
GSL::Vector#*(b)
GSL::Vector#sub!(b)
GSL::Vector#-=(b)
GSL::Vector#sub(b)
GSL::Vector#-(b)
GSL::Vector#div!(b)
GSL::Vector#/=(b)
GSL::Vector#div(b)
GSL::Vector#/(b)
GSL::Vector#mul(b)
GSL::Vector#*(b)
ex1: Scale
irb(main):027:0> v = Vector.new(1, 2) [ 1 2 ] => #<GSL::Vector:0x77a8d0> irb(main):028:0> v*2 [ 2 4 ] => #<GSL::Vector:0x7794e4>
ex2: Element-by-element multiplication
irb(main):018:0> a = Vector.new(1, 2); b = Vector.new(3, 4) [ 3 4 ] => #<GSL::Vector:0x78f500> irb(main):020:0> a*b [ 3 8 ] => #<GSL::Vector:0x78e074>
ex3: Inner product
irb(main):023:0> a = Vector.new(1, 2); b = Vector::Col.new(3, 4) [ 3 4 ] => #<GSL::Vector::Col:0x7840c4> irb(main):024:0> a*b => 11.0
ex4: Vector::Col*Vector -> Matrix
irb(main):025:0> a = Vector::Col.new(1, 2); b = Vector.new(3, 4) [ 3 4 ] => #<GSL::Vector:0x77e458> irb(main):026:0> a*b [ 3 4 6 8 ] => #<GSL::Matrix:0x77cfcc>
ex5: Matrix*Vector::Col -> Vector::Col
irb(main):029:0> a = Vector.new(1, 2); m = Matrix.new([2, 3], [4, 5]) [ 2 3 4 5 ] => #<GSL::Matrix:0x774160> irb(main):030:0> m*a <--- Error TypeError: Operation with GSL::Vector is not defined (GSL::Vector::Col expected) from (irb):30:in `*' from (irb):30 irb(main):031:0> m*a.col [ 8 14 ] => #<GSL::Vector::Col:0x771230>
GSL::Vector#scale!(x)
GSL::Vector#scale(x)
GSL::Vector#add_constant!(x)
GSL::Vector#add_constant(x)
GSL::Vector#reverse
GSL::Vector#swap_elements
GSL::Vector#clone
GSL::Vector#max
GSL::Vector#min
GSL::Vector#minmax
GSL::Vector#max_index
GSL::Vector#min_index
GSL::Vector#minmax_index
GSL::Vector#isnull
GSL::Vector#isnull?
true
if all the elements of the vector self
are zero, and false
otherwise.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]) 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
GSL::Vector.na_to_gv(na)
GSL::Vector.na_to_gslv(na)
GSL::Vector.to_gv(na)
GSL::Vector.to_gslv(na)
GSL::Vector::View
object is created from the NArray object na.
The 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.