### Home Classes Methods

### Files

- alf.rdoc
- blas.rdoc
- bspline.rdoc
- changes.rdoc
- cheb.rdoc
- cholesky_complex.rdoc
- combi.rdoc
- complex.rdoc
- const.rdoc
- dht.rdoc
- diff.rdoc
- ehandling.rdoc
- eigen.rdoc
- fft.rdoc
- fit.rdoc
- function.rdoc
- graph.rdoc
- hist.rdoc
- hist2d.rdoc
- hist3d.rdoc
- index.rdoc
- integration.rdoc
- interp.rdoc
- intro.rdoc
- linalg.rdoc
- linalg_complex.rdoc
- math.rdoc
- matrix.rdoc
- min.rdoc
- monte.rdoc
- multimin.rdoc
- multiroot.rdoc
- narray.rdoc
- ndlinear.rdoc
- nonlinearfit.rdoc
- ntuple.rdoc
- odeiv.rdoc
- perm.rdoc
- poly.rdoc
- qrng.rdoc
- randist.rdoc
- ref.rdoc
- rng.rdoc
- rngextra.rdoc
- roots.rdoc
- screenshot.rdoc
- sf.rdoc
- siman.rdoc
- sort.rdoc
- start.rdoc
- stats.rdoc
- sum.rdoc
- tensor.rdoc
- tut.rdoc
- use.rdoc
- vector.rdoc
- vector_complex.rdoc
- wavelet.rdoc

### Class Index

Quicksearch

No matching classes.

# GSL::Vector class

Contents:

1. Class methods

2. Notes

3. Methods

   1. Accessing vector elements

   2. Initializing vector elements

   3. Iterators

   4. IO

   5. Copying vectors

   6. Vector views

   7. Vector operations

   8. Vector operations with size changes

   9. Finding maximum and minimum elements of vectors

   10. Vector properties

   11. Element-wise vector comparison

   12. Histogram

   13. Sorting

   14. BLAS methods

   15. Data type conversions

4. NArray

5. GNU graph interface

See also GSL::Vector::Complex.

## Class methods

- GSL::Vector.alloc(ary)

- GSL::Vector.alloc(ary)

- GSL::Vector.alloc(range)

- GSL::Vector.alloc(size)

- GSL::Vector.alloc(elm0, elm1, ....)

- GSL::Vector[elm0, elm1, ....]

  Constructors.

  Ex:

      >> v1 = GSL::Vector.alloc(5)
      => GSL::Vector: [ 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 ]
      >> v2 = GSL::Vector.alloc(1, 3, 5, 2)
      => GSL::Vector: [ 1.000e+00 3.000e+00 5.000e+00 2.000e+00 ]
      >> v3 = GSL::Vector[1, 3, 5, 2]
      => GSL::Vector: [ 1.000e+00 3.000e+00 5.000e+00 2.000e+00 ]
      >> v4 = GSL::Vector.alloc([1, 3, 5, 2])
      => GSL::Vector: [ 1.000e+00 3.000e+00 5.000e+00 2.000e+00 ]
      >> v5 = GSL::Vector[1..6]
      => GSL::Vector: [ 1.000e+00 2.000e+00 3.000e+00 4.000e+00 5.000e+00 6.000e+00 ]

- GSL::Vector.calloc(size)

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

- GSL::Vector.linspace(min, max, n = 10)

  Creates an `GSL::Vector` with `n` linearly spaced elements between `min` and `max`. If `min` is greater than `max`, the elements are stored in decreasing order. This mimics the `linspace` function of GNU Octave.

  Ex:

      >> x = GSL::Vector.linspace(0, 10, 5)
      [ 0.000e+00 2.500e+00 5.000e+00 7.500e+00 1.000e+01 ]
      >> y = GSL::Vector.linspace(10, 0, 5)
      [ 1.000e+01 7.500e+00 5.000e+00 2.500e+00 0.000e+00 ]

- GSL::Vector.logspace(min, max, n)

  Similar to `GSL::Vector#linspace` except that the values are logarithmically spaced from 10^`min` to 10^`max`.

  Ex:

      >> x = GSL::Vector.logspace(1, 3, 5)
      [ 1.000e+01 3.162e+01 1.000e+02 3.162e+02 1.000e+03 ]
      >> x = GSL::Vector.logspace(3, 1, 5)
      [ 1.000e+03 3.162e+02 1.000e+02 3.162e+01 1.000e+01 ]

- GSL::Vector.logspace2(min, max, n)

  Similar to `GSL::Vector#linspace` except that the values are logarithmically spaced from `min` to `max`.

  Ex:

      >> x = GSL::Vector.logspace2(10, 1000, 5)
      [ 1.000e+01 3.162e+01 1.000e+02 3.162e+02 1.000e+03 ]
      >> x = GSL::Vector.logspace2(1000, 10, 5)
      [ 1.000e+03 3.162e+02 1.000e+02 3.162e+01 1.000e+01 ]

- GSL::Vector.indgen(n, start=0, step=1)

  This creates a vector of length `n` with elements from `start` with interval `step` (mimics NArray#indgen).

  Ex:

      >> v = GSL::Vector::Int.indgen(5)
      => GSL::Vector::Int:
      [ 0 1 2 3 4 ]
      >> v = GSL::Vector::Int.indgen(5, 3)
      => GSL::Vector::Int:
      [ 3 4 5 6 7 ]
      >> v = GSL::Vector.indgen(4, 1.2, 0.3)
      => GSL::Vector
      [ 1.200e+00 1.500e+00 1.800e+00 2.100e+00 ]

- GSL::Vector.filescan(filename)

  Reads a formatted ascii file and returns an array of vectors. For a data file `a.dat` as

      1 5 6 5
      3 5 6 7
      5 6 7 9

  then `a, b, c, d = Vetor.filescan("a.dat")` yields

      a = [1, 3, 5]
      b = [5, 5, 6]
      c = [6, 6, 7]
      d = [5, 7, 9]

### NArray Extension

If an `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 = GSL::Vector.alloc(na)
    p v                 <----- [ 1 2 3 4 5 ]

See also here.

## NOTE:

In Ruby/GSL, vector length is limited within the range of Fixnum. For 32-bit CPU, the maximum of vector length is 2^30 ~ 1e9.

## Methods

### Accessing vector elements

- GSL::Vector#get(args)

- GSL::Vector#

  Returns elements(s) of the vector `self` if `args` is a single `Fixnum`, a single `Array` of `Fixnums`, or a single `GSL::Permutation` (or `GSL::Index`). For all other `args`, the arguments are treated as with `Vector#subvector` and a `Vector::View` is returned.

- GSL::Vector#set(args, val)

- GSL::Vector# = val

  If `args` is empty, behaves as `#set_all` and `val` must be a `Numeric`.

  If `args` is a single `Fixnum`, `i`, sets the `i`-th element of the vector `self` to `val`, which must be a `Numeric`.

  All other `args` specify a subvector (as with `#subvector`) whose elements are assigned from `val`. In this case, `val` can be an `Array`, `Range`, `GSL::Vector`, or `Numeric`.

  NOTE: GSL does not provide a vector copy function that properly copies data across overlapping memory regions, so watch out if assigning to part of a Vector from another part of itself (see example below).

  Ex:

      >> require 'gsl'
      => true
      >> v = GSL::Vector[0..5]
      => GSL::Vector
      [ 0.000e+00 1.000e+00 2.000e+00 3.000e+00 4.000e+00 5.000e+00 ]
      >> v[2]
      => 2.0
      >> v[1,2,3]
      => GSL::Vector::View
      [ 1.000e+00 3.000e+00 5.000e+00 ]
      >> v[[1,2,3]]
      => GSL::Vector
      [ 1.000e+00 2.000e+00 3.000e+00 ]
      >> v[3] = 9
      => 9
      >> v[-1] = 123
      => 123
      >> v
      => GSL::Vector
      [ 0.000e+00 1.000e+00 2.000e+00 9.000e+00 4.000e+00 1.230e+02 ]
      >> v[2,3] = 0
      => 0
      >> v
      => GSL::Vector
      [ 0.000e+00 1.000e+00 0.000e+00 0.000e+00 0.000e+00 1.230e+02 ]
      >> v[2,3] = [4,5,6]
      => [4, 5, 6]
      >> v
      => GSL::Vector
      [ 0.000e+00 1.000e+00 4.000e+00 5.000e+00 6.000e+00 1.230e+02 ]
      >> v[1,4] = v[0,4] # !!! Overlapping !!!
      => GSL::Vector::View
      [ 0.000e+00 0.000e+00 0.000e+00 0.000e+00 ]
      >> v
      => GSL::Vector
      [ 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 1.230e+02 ]

### Initializing vector elements

- GSL::Vector#set_all(x)

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

- 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 size 10, the method

      v.set_basis!(4)

  sets the vector `v` to a basis vector `[0, 0, 0, 0, 1, 0, 0, 0, 0, 0]`.

- GSL::Vector#set_basis(i)

  This method returns a new 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 size 10, the method

      vb = v.set_basis(4)

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

- GSL::Vector#indgen!(start=0, step=1)

- GSL::Vector#indgen(start=0, step=1)

  Mimics NArray#indgen!.

### Iterators

- GSL::Vector#each

- GSL::Vector#reverse_each

  An iterator for each of the vector elements, used as

      v.each do |x|    # Show all the elements
        p x
      end

- GSL::Vector#each_index

- GSL::Vector#reverse_each_index

  Iterators

- GSL::Vector#collect { |item| .. }

- GSL::Vector#map { |item| .. }

  Creates a new vector by collecting the vector elements modified with some operations.

  Ex:

      >> a = GSL::Vector::Int[0..5]
      => GSL::Vector::Int
      [ 0 1 2 3 4 5 ]
      >> b = a.collect {|v| v*v}
      => GSL::Vector::Int
      [ 0 1 4 9 16 25 ]
      >> a
      => GSL::Vector::Int
      [ 0 1 2 3 4 5 ]

- GSL::Vector#collect! { |item| .. }

- GSL::Vector#map! { |item| .. }

  Ex:

      >> a = GSL::Vector::Int[0..5]
      => GSL::Vector::Int
      [ 0 1 2 3 4 5 ]
      >> a.collect! {|v| v*v}
      => GSL::Vector::Int
      [ 0 1 4 9 16 25 ]
      >> a
      => GSL::Vector::Int
      [ 0 1 4 9 16 25 ]

### IO

- 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)

  Methods for writing or reading the vector. The first argument is an `IO` or a `String` object.

### Copying vectors

- GSL::Vector#clone

- GSL::Vector#duplicate

  Create a new vector of the same elements.

### Vector views

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

- GSL::Vector#subvector

- GSL::Vector#subvector(n)

- GSL::Vector#subvector(offset, n)

- GSL::Vector#subvector(offset, stride, n)

- GSL::Vector#subvector(range, stride=1)

  Create 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. If called with a `range` parameter (and optional `stride`), a view is created for that range (and stride). Note the `n`, if given, is the length of the returned View.

  - Example:

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

        v = GSL::Vector[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(stride)

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

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

  Return a `Vector::View` object of a subvector of another vector `self` with an additional stride argument. The subvector is formed in the same way as for `Vector#subvector` but the new vector view has `n` elements with a step-size of `stride` from one element to the next in the original vector. Note that `n`, if given, is the length of the returned View.

- GSL::Vector#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:

        >> v = GSL::Vector::Int.alloc(1..9)
        => GSL::Vector::Int:
        [ 1 2 3 4 5 6 7 8 9 ]
        >> m = v.matrix_view(3, 3)
        => GSL::Matrix::Int::View:
        [ 1 2 3
          4 5 6
          7 8 9 ]
        >> m[1][2] = 99
        => 99
        >> v
        => GSL::Vector::Int:
        [ 1 2 3 4 5 99 7 8 9 ]

### Vector operations

- GSL::Vector#swap_elements(i, j)

  This method exchanges the i-th and j-th elements of the vector `in-place`.

- GSL::Vector#reverse

  Reverses the order of the elements of the vector.

      >> v = GSL::Vector::Int[1..5]
      => GSL::Vector::Int:
      [ 1 2 3 4 5 ]
      >> v.reverse
      => GSL::Vector::Int:
      [ 5 4 3 2 1 ]

- GSL::Vector#trans

- GSL::Vector#transpose

- GSL::Vector#col

- GSL::Vector#row

  Transpose the vector from a row vector into a column vector and vice versa.

      >> v = GSL::Vector::Int[1..5]
      => GSL::Vector::Int:
      [ 1 2 3 4 5 ]
      >> v.col
      => GSL::Vector::Int::Col:
      [ 1
        2
        3
        4
        5 ]

- GSL::Vector#add(b)

  Adds the elements of vector `b` to the elements of the vector `self`. A new vector is created, and the vector `self` is not changed.

- GSL::Vector#sub(b)

  Subtracts the element of vector `b` from the elements of `self`. A new vector is created, and the vector `self` is not changed.

- GSL::Vector#mul(b)

  Multiplies the elements of vector `self` by the elements of vector `b`.

- GSL::Vector#div(b)

  Divides the elements of vector `self` by the elements of vector `b`.

- 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)

  Adds the constant value `x` to the elements of the vector `self`.

- GSL::Vector#+(b)

  For `b`,

      * a Number: ---> <tt>self.add_constanb(b)</tt>
      * a Vector: ---> <tt>self.add(b)</tt>

- GSL::Vector#-(b)

  For `b`,

      * a Number: ---> <tt>self.add_constanb(-b)</tt>
      * a Vector: ---> <tt>self.sub(b)</tt>

- GSL::Vector#/(b)

  For `b`,

      * a Number: ---> <tt>self.scale(1/b)</tt>
      * a Vector: ---> <tt>self.div(b)</tt>

- GSL::Vector#*(b)

  Vector multiplication.

1. Scale

       >> v = GSL::Vector[1, 2]
       [ 1 2 ]
       >> v*2
       [ 2 4 ]

2. Element-by-element multiplication

       >> a = GSL::Vector[1, 2]; b = GSL::Vector[3, 4]
       [ 3 4 ]
       >> a*b
       [ 3 8 ]

3. Inner product

       >> a = GSL::Vector[1, 2]; b = GSL::Vector[3, 4]
       [ 3
         4 ]
       >> a*b.col
       => 11.0

4. GSL::Vector::Col*Vector -> GSL::Matrix

       >> a = GSL::Vector::Col[1, 2]; b = GSL::Vector[3, 4]
       [ 3 4 ]
       >> a*b
       [ 3 4
         6 8 ]

5. GSL::Matrix*Vector::Col -> GSL::Vector::Col

       >> a = GSL::Vector[1, 2]; m = GSL::Matrix[[2, 3], [4, 5]]
       [ 2 3
         4 5 ]
       >> m*a          <--- Error
       TypeError: Operation with GSL::Vector is not defined (GSL::Vector::Col expected)
               from (irb):30:in `*'
               from (irb):30
       >> m*a.col
       [ 8
         14 ]

- GSL::Vector#add!(b)

- GSL::Vector#sub!(b)

- GSL::Vector#mul!(b)

- GSL::Vector#div!(b)

  In-place operations with a vector `b`.

- GSL::Vector#pow(p)

- GSL::Vector#**(p)

- GSL::Vector#pow!(p)

  Element-wise calculation of power p.

  Ex)

      >> require("gsl")
      >> v = GSL::Vector[1, 2, 3]
      => GSL::Vector
      [ 1.000e+00 2.000e+00 3.000e+00 ]
      >> v.pow(2)
      => GSL::Vector
      [ 1.000e+00 4.000e+00 9.000e+00 ]
      >> v**2
      => GSL::Vector
      [ 1.000e+00 4.000e+00 9.000e+00 ]
      >> v
      => GSL::Vector
      [ 1.000e+00 2.000e+00 3.000e+00 ]
      >> v.pow!(2)
      => GSL::Vector
      [ 1.000e+00 4.000e+00 9.000e+00 ]
      >> v
      => GSL::Vector
      [ 1.000e+00 4.000e+00 9.000e+00 ]

- GSL::Vector#swap_elements(i, j)

  This exchanges the `i`-th and `j`-th elements of the vector `self` in-place.

- GSL::Vector#clone

- GSL::Vector#duplicate

  These create a copy of the vector `self`.

- GSL::Vector.connect(v1, v2, v3, ...)

- GSL::Vector#connect(v2, v3, ...)

  Creates a new vector by connecting all the elements of the given vectors.

      >> v1 = GSL::Vector::Int[1, 3]
      => GSL::Vector::Int:
      [ 1 3 ]
      >> v2 = GSL::Vector::Int[4, 3, 5]
      => GSL::Vector::Int:
      [ 4 3 5 ]
      >> v1.connect(v2)
      => GSL::Vector::Int:
      [ 1 3 4 3 5 ]

- GSL::Vector#sgn

- GSL::Vector#signum

  Creates a new vector, with elements +1 if `x_i` > 0, -1 if `x_i` < 0, otherwise 0. Note that this definition gives the signum of NaN as 0 rather than NaN.

- GSL::Vector#abs

- GSL::Vector#fabs

  Creates a new vector, with elements `fabs(x_i)`.

      >> v = GSL::Vector::Int[-3, 2, -5, 4]
      => GSL::Vector::Int:
      [ -3 2 -5 4 ]
      >> v.abs
      => GSL::Vector::Int:
      [ 3 2 5 4 ]

- GSL::Vector#square

- GSL::Vector#abs2

  Create a new vector, with elements `x_i*x_i`.

      >> v = GSL::Vector::Int[1..4]
      => GSL::Vector::Int:
      [ 1 2 3 4 ]
      >> v.square
      => GSL::Vector::Int:
      [ 1 4 9 16 ]

- GSL::Vector#sqrt

  Creates a new vector, with elements `sqrt`(`x_i`).

- GSL::Vector#floor

- GSL::Vector#ceil

- GSL::Vector#round

  Ex:

      >> v = GSL::Vector[1.1, 2.7, 3.5, 4.3]
      => GSL::Vector
      [ 1.100e+00 2.700e+00 3.500e+00 4.300e+00 ]
      >> v.floor
      => GSL::Vector::Int
      [ 1 2 3 4 ]
      >> v.ceil
      => GSL::Vector::Int
      [ 2 3 4 5 ]
      >> v.round
      => GSL::Vector::Int
      [ 1 3 4 4 ]

- GSL::Vector#normalize(nrm = 1.0)

  Creates a new vector of norm `nrm`, by scaling the vector `self`.

- GSL::Vector#normalize!(nrm = 1.0)

  This normalizes the vector `self` in-place.

  Ex:

      tcsh> irb
      >> require("gsl")
      => true
      >> a = GSL::Vector[-1, -2, -3, -4]
      => GSL::Vector:
      [ -1.000e+00 -2.000e+00 -3.000e+00 -4.000e+00 ]
      >> b = a.abs
      => GSL::Vector:
      [ 1.000e+00 2.000e+00 3.000e+00 4.000e+00 ]
      >> b.sqrt
      => GSL::Vector:
      [ 1.000e+00 1.414e+00 1.732e+00 2.000e+00 ]
      >> b.square
      => GSL::Vector:
      [ 1.000e+00 4.000e+00 9.000e+00 1.600e+01 ]
      >> c = b.normalize(2)
      => GSL::Vector:
      [ 2.582e-01 5.164e-01 7.746e-01 1.033e+00 ]
      >> c.square.sum
      => 2.0

- GSL::Vector#decimate(n)

  Creates a new vector by averaring every `n` points of the vector `self` down to one point.

- GSL::Vector#diff(k = 1)

  Calculate `k`-th differences of a vector `self`.

- GSL::Vector#join(sep = " ")

  Converts the vector to a `String` by joining all the elements with a separator `sep`.

- GSL::Vector#zip(vec, ...)

- GSL::Vector.zip(vec, ...)

  Create an `Array` of vectors by merging the elements of `self` with corresponding elements from each arguments.

  Ex:

      >> require("gsl")
      >> a = GSL::Vector[4, 5, 6]
      >> b = GSL::Vector[7, 8, 9]
      >> GSL::Vector[1, 2, 3].zip(a, b)
      [[ 1.000e+00 4.000e+00 7.000e+00 ],
       [ 2.000e+00 5.000e+00 8.000e+00 ],
       [ 3.000e+00 6.000e+00 9.000e+00 ]]
      >> GSL::Vector[1, 2].zip(a, b)
      [[ 1.000e+00 4.000e+00 7.000e+00 ],
       [ 2.000e+00 5.000e+00 8.000e+00 ]]
      >> a.zip(GSL::Vector[1, 2], GSL::Vector[8.0])
      [[ 4.000e+00 1.000e+00 8.000e+00 ],
       [ 5.000e+00 2.000e+00 0.000e+00 ],
       [ 6.000e+00 0.000e+00 0.000e+00 ]]

- GSL::Vector#concat(x)

  Returns a new Vector that contains the concatenation `self` and `x`, which must be an `Array`, `Fixnum`, `Bignum`, `Float`, `Range`, or `GSL::Vector`.

### Vector operations with size changes

The methods below change vector length of `self`. A Vector's length may not extend past its original allocation. Use of these methods is discouraged. Existing Views may still refer to elements beyond the end of the shortened Vector. These elements remain allocated, but are effectvely unmanaged.

- GSL::Vector#delete(x)

  Deletes items from `self` that are equal to `x`. If the item is not found, returns `nil`, otherwise returns `x`.

- GSL::Vector#delete_at(i)

  Deletes the element at the specified index `i`, returning that element, or `nil` if the index is out of range.

- GSL::Vector#delete_if { |x| ... }

  Deletes every element of `self` for which block evaluates to `true` and returns `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`.

### Vector Properties

- GSL::Vector#size

- GSL::Vector#len

- GSL::Vector#length

  Return the vector length.

- GSL::Vector#stride

  Return the vector stride.

- GSL::Vector#sum

  Returns the sum of the vector elements.

- GSL::Vector#prod

  Returns the product of the vector elements.

- GSL::Vector#cumsum

  Calculate the cumulative sum of elements of `self` and returns as a new vector.

- GSL::Vector#cumprod

  Calculate the cumulative product of elements of `self` and returns as a new vector.

- GSL::Vector#isnull

  Returns 1 if all the elements of the vector `self` are zero, and 0 otherwise.

- GSL::Vector#isnull?

  Return `true` if all the elements of the vector `self` are zero, and `false` otherwise.

- GSL::Vector#ispos

- GSL::Vector#ispos?

- GSL::Vector#isneg

- GSL::Vector#isneg?

  (GSL-1.9 or later) Return 1 (true) if all the elements of the vector `self` are zero, strictly positive, strictly negative respectively, and 0 (false) otherwise.

- GSL::Vector#isnonneg

- GSL::Vector#isnonneg?

  (GSL-1.10 or later) Return 1 (true) if all the elements of the vector `self` are non-negative , and 0 (false) otherwise.

- GSL::Vector#all?

  Returns `true` if all the vector elements are non-zero, and `false` otherwise. If a block is given, the method returns `true` if the tests are true for all the elements.

- GSL::Vector#any?

  Returns `true` if any the vector elements are non-zero, and `false` otherwise. If a block is given, the method returns `true` if the tests are true for any of the elements.

- GSL::Vector#none?

  Returns `true` if all the elements of the vector `self` are zero, and `false` otherwise (just as `GSL::Vector#isnull?`). If a block is given, the method returns `true` if the tests are false for all the elements.

  Ex:

      >> a = GSL::Vector[1, 2, 3]
      >> b = GSL::Vector[1, 2, 0]
      >> c = GSL::Vector[0, 0, 0]
      >> a.all?
      => true
      >> b.all?
      => false
      >> b.any?
      => true
      >> c.any?
      => false
      >> a.none?
      => false
      >> c.none?
      => true

- GSL::Vector#all

- GSL::Vector#any

- GSL::Vector#none

  Returns 1 or 0.

- GSL::Vector#equal?(other, eps = 1e-10)

- GSL::Vector#==(other, eps = 1e-10)

  Returns `true` if the vectors have same size and elements equal to absolute accurary `eps` for all the indices, and `false` otherwise.

### Element-wise vector comparison

- GSL::Vector#eq(other)

- GSL::Vector#ne(other)

- GSL::Vector#gt(other)

- GSL::Vector#ge(other)

- GSL::Vector#lt(other)

- GSL::Vector#le(other)

  Return a `Block::Byte` object with elements 0/1 by comparing the two vectors `self` and `other`. Note that the values returned are 0/1, not `true/false`, thus all of the elements are "true" in Ruby.

  Ex:

      >> a = GSL::Vector[1, 2, 3]
      >> b = GSL::Vector[1, 2, 5]
      >> a.eq(b)
      [ 1 1 0 ]
      >> a.ne(b)
      [ 0 0 1 ]
      >> a.gt(b)
      [ 0 0 0 ]
      >> a.ge(b)
      [ 1 1 0 ]
      >> a.eq(3)
      [ 0 0 1 ]
      >> a.ne(2)
      [ 1 0 1 ]
      >> a.ge(2)
      [ 0 1 1 ]

- GSL::Vector#and(other)

- GSL::Vector#or(other)

- GSL::Vector#xor(other)

- GSL::Vector#not

  Ex:

      >> a = GSL::Vector[1, 0, 3, 0]
      >> b = GSL::Vector[3, 4, 0, 0]
      >> a.and(b)
      [ 1 0 0 0 ]
      >> a.or(b)
      [ 1 1 1 0 ]
      >> a.xor(b)
      [ 0 1 1 0 ]
      >> a.not
      [ 0 1 0 1 ]
      >> b.not
      [ 0 0 1 1 ]

- GSL::Vector#where

- GSL::Vector#where { |elm| ... }

  Returns the vector indices where the tests are true. If all the test failed `nil` is returned.

  Ex:

      >> v = GSL::Vector::Int[0, 3, 0, -2, 3, 5, 0, 3]
      >> v.where
      [ 1 3 4 5 7 ]                   # where elements are non-zero
      >> v.where { |elm| elm == -2 }
      [ 3 ]
      >> a = GSL::Vector[0, 0, 0]
      >> a.where
      => nil

### Histogram

- GSL::Vector#histogram(n)

- GSL::Vector#histogram(ranges)

- GSL::Vector#histogram(n, min, max)

- GSL::Vector#histogram(n, [min, max])

  Creates a histogram filling the vector `self`.

  Example:

      >> r = GSL::Rng.alloc           # Random number generator
      => #<GSL::Rng:0x6d8594>
      >> v = r.gaussian(1, 1000)    # Generate 1000 Gaussian random numbers
      => GSL::Vector
      [ 1.339e-01 -8.810e-02 1.674e+00 7.336e-01 9.975e-01 -1.278e+00 -2.397e+00 ... ]
      >> h = v.histogram(50, [-4, 4])  # Creates a histogram of size 50, range [-4, 4)
      => #<GSL::Histogram:0x6d28b0>
      >> h.graph("-T X -C -g 3")    # Show the histogram
      => true

  This is equivalent to

      h = Histogram.alloc(50, [-4, 4])
      h.increment(v)

### Sorting

- GSL::Vector#sort

- GSL::Vector#sort!

  These methods sort the vector `self` in ascending numerical order.

- GSL::Vector#sort_index

  This method indirectly sorts the elements of the vector `self` into ascending order, and returns the resulting permutation. The elements of permutation give the index of the vector element which would have been stored in that position if the vector had been sorted in place. The first element of permutation gives the index of the least element in the vector, and the last element of permutation gives the index of the greatest vector element. The vector `self` is not changed.

- GSL::Vector#sort_smallest(n)

- GSL::Vector#sort_largest(n)

- GSL::Vector#sort_smallest_index(n)

- GSL::Vector#sort_largest_index(n)

  Ex:

      >> v = GSL::Vector::Int[8, 2, 3, 7, 9, 1, 4]
      => GSL::Vector::Int:
      [ 8 2 3 7 9 1 4 ]
      >> v.sort
      => GSL::Vector::Int:
      [ 1 2 3 4 7 8 9 ]
      >> v.sort_index
      => GSL::Permutation:
      [ 5 1 2 6 3 0 4 ]
      >> v.sort_largest(3)
      => GSL::Vector::Int:
      [ 9 8 7 ]
      >> v.sort_smallest(3)
      => GSL::Vector::Int:
      [ 1 2 3 ]

### BLAS Methods

- GSL::Vector#nrm2

- GSL::Vector#dnrm2

  Compute the Euclidean norm ||x||_2 = sqrt {sum x_i^2} of the vector.

- GSL::Vector#asum

- GSL::Vector#dasum

  Compute the absolute sum sum |x_i| of the elements of the vector.

### Data type conversions

- 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_m(nrow, ncol)

  Creates a `GSL::Matrix` object of `nrow` rows and `ncol` columns.

      >> v = GSL::Vector::Int[1..5]
      => GSL::Vector::Int:
      [ 1 2 3 4 5 ]
      >> v.to_m(2, 3)
      => GSL::Matrix::Int:
      [ 1 2 3
        4 5 0 ]
      >> v.to_m(2, 2)
      => GSL::Matrix::Int:
      [ 1 2
        3 4 ]
      >> v.to_m(3, 2)
      => GSL::Matrix::Int:
      [ 1 2
        3 4
        5 0 ]

- GSL::Vector#to_m_diagonal

  Converts the vector into a diagonal matrix. See also GSL::Matrix.diagonal(v).

      >> v = GSL::Vector[1..4].to_i
      => GSL::Vector::Int:
      [ 1 2 3 4 ]
      >> v.to_m_diagonal
      => GSL::Matrix::Int:
      [ 1 0 0 0
        0 2 0 0
        0 0 3 0
        0 0 0 4 ]

- GSL::Vector#to_m_circulant

  Creates a circulant matrix.

      >> v = GSL::Vector::Int[1..5]
      => GSL::Vector::Int:
      [ 1 2 3 4 5 ]
      >> v.to_m_circulant
      => GSL::Matrix::Int:
      [ 5 1 2 3 4
        4 5 1 2 3
        3 4 5 1 2
        2 3 4 5 1
        1 2 3 4 5 ]

- GSL::Vector#to_complex

- GSL::Vector#to_complex2

  Example:

      >> v = GSL::Vector[1..4]
      => GSL::Vector
      [ 1.000e+00 2.000e+00 3.000e+00 4.000e+00 ]
      >> v.to_complex
      [ [1.000e+00 0.000e+00] [2.000e+00 0.000e+00] [3.000e+00 0.000e+00] [4.000e+00 0.000e+00] ]
      => #<GSL::Vector::Complex:0x6d7d24>
      >> v.to_complex2
      [ [1.000e+00 2.000e+00] [3.000e+00 4.000e+00] ]
      => #<GSL::Vector::Complex:0x6d6424>

- GSL::Vector#to_tensor(rank, dimension)

### GSL::Vector <---> NArray

- GSL::Vector#to_na

  Converts a vector `self` into an `NArray` object. The data are copied to newly allocated memory.

- GSL::Vector#to_na2

- GSL::Vector#to_na_ref

  Create an `NArray` reference of the vector `self`.

  Example:

      >> v = GSL::Vector::Int[1, 2, 3, 4]
      => GSL::Vector::Int
      [ 1 2 3 4 ]
      >> na = v.to_na
      => NArray.int(4):
      [ 1, 2, 3, 4 ]
      >> na2 = v.to_na2
      => NArray(ref).int(4):
      [ 1, 2, 3, 4 ]
      >> na[1] = 99
      => 99
      >> v              # na and v are independent
      => GSL::Vector::Int
      [ 1 2 3 4 ]
      >> na2[1] = 99    # na2 points to the data of v
      => 99
      >> v
      => GSL::Vector::Int
      [ 1 99 3 4 ]

- NArray#to_gv

- NArray#to_gslv

  Create `GSL::Vector` object from the `NArray` object `self`.

- NArray#to_gv_view

- NArray#to_gv2

- NArray#to_gslv_view

  A `GSL::Vector::View` object is created from the NArray object `self`. This method does not allocate memory for the data: the data of `self` are not copied, but shared with the `View` object created, thus any modifications to the `View` object affect on the original NArray object. In other words, the `View` object can be used as a `reference` to the NArray object.

  Ex:

      tcsh> irb
      >> require("gsl")
      => true
      >> na = NArray[1.0, 2, 3, 4, 5]
      => NArray.float(5):
      [ 1.0, 2.0, 3.0, 4.0, 5.0 ]
      >> vv = na.to_gv_view   # Create a view sharing the memory
      => GSL::Vector::View
      [ 1.000e+00 2.000e+00 3.000e+00 4.000e+00 5.000e+00 ]
      >> vv[3] = 9
      => 9
      >> na
      => NArray.float(5):
      [ 1.0, 2.0, 3.0, 9.0, 5.0 ]           # The data are changed
      >> v = na.to_gv         # A vector with newly allocated memory
      => GSL::Vector
      [ 1.000e+00 2.000e+00 3.000e+00 9.000e+00 5.000e+00 ]
      >> v[1] = 123
      => 123
      >> v
      => GSL::Vector
      [ 1.000e+00 1.230e+02 3.000e+00 9.000e+00 5.000e+00 ]
      >> na
      => NArray.float(5):
      [ 1.0, 2.0, 3.0, 9.0, 5.0 ]           # v and na are independent
      >> na = NArray[1.0, 2, 3, 4, 5, 6]
      => NArray.float(6):
      [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ]
      >> m = na.to_gv_view.matrix_view(2, 3)
      => GSL::Matrix::View
      [  1.000e+00  2.000e+00  3.000e+00
         4.000e+00  5.000e+00  6.000e+00 ]
      >> m[1][2] = 9
      => 9
      >> na
      => NArray.float(6):
      [ 1.0, 2.0, 3.0, 4.0, 5.0, 9.0 ]

### Graphics

- GSL::Vector.graph(y)

- GSL::Vector.graph(y, options)

- GSL::Vector.graph(x, y)

- GSL::Vector.graph(x, y, options)

- GSL::Vector#graph(options)

- GSL::Vector#graph(x, options)

  These methods use the GNU plotutils `graph` application to plot a vector `self`. The options of `graph` as "-T X -C" can be given by a String.

  Example:

      >> x = GSL::Vector.linspace(0, 2.0*M_PI, 20)
      >> c = GSL::Sf::cos(x)
      >> s = GSL::Sf::sin(x)
      >> GSL::Vector.graph(x, c, s, "-T X -C -L 'cos(x), sin(x)'")

prev next

Reference index top

[Validate]

Generated with the Darkfish Rdoc Generator 2.