Module: NVector

Defined in:
lib/nmatrix/shortcuts.rb

Overview

:nodoc:

Class Method Summary collapse

Class Method Details

.bindgen(n) ⇒ Object

call-seq: bindgen(n) -> NVector

Returns a byte NVector. Equivalent to seq(n, :byte).

  • Arguments :
    • n -> Size of the sequence.
  • Returns :
    • NVector filled with n integers of dtype :byte.


1042
1043
1044
 
# File 'lib/nmatrix/shortcuts.rb', line 1042

def bindgen(n)
  NVector.seq(n, :byte)
end

.cindgen(n) ⇒ Object

call-seq: cindgen(n) -> NVector

Returns a complex NVector. Equivalent to seq(n, :complex64).

  • Arguments :
    • n -> Size of the sequence.
  • Returns :
    • NVector filled with n integers of dtype :complex64.


1057
1058
1059
 
# File 'lib/nmatrix/shortcuts.rb', line 1057

def cindgen(n)
  NVector.seq(n, :complex64)
end

.findgen(n) ⇒ Object

call-seq: findgen(n) -> NVector

Returns a float NVector. Equivalent to seq(n, :float32).

  • Arguments :
    • n -> Size of the sequence.
  • Returns :
    • NVector filled with n integers of dtype :float32.


1027
1028
1029
 
# File 'lib/nmatrix/shortcuts.rb', line 1027

def findgen(n)
  NVector.seq(n, :float32)
end

.indgen(n) ⇒ Object

call-seq: indgen(n) -> NVector

Returns an integer NVector. Equivalent to seq(n, :int32).

  • Arguments :
    • n -> Size of the sequence.
  • Returns :
    • NVector filled with n integers of dtype :int32.


1012
1013
1014
 
# File 'lib/nmatrix/shortcuts.rb', line 1012

def indgen(n)
  NVector.seq(n, :int32)
end

.linspace(a, b, n = 100) ⇒ Object

call-seq: linspace(a, b) -> NVector linspace(a, b, n) -> NVector

Returns a NVector with n values of dtype :float64 equally spaced from a to b, inclusive.

See: http://www.mathworks.com/help/matlab/ref/linspace.html

  • Arguments :
    • a -> The first value in the sequence.
    • b -> The last value in the sequence.
    • n -> The number of elements. Default is 100.
  • Returns :
    • NVector with n :float64 values.

Example:

x = NVector.linspace(0, Math::PI, 1000)
x.pretty_print
[0.0
0.0031447373909807737
0.006289474781961547
...
3.135303178807831
3.138447916198812
3.141592653589793]
=> nil


1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
 
# File 'lib/nmatrix/shortcuts.rb', line 1090

def linspace(a, b, n = 100)
  # Formula: seq(n) * step + a

  # step = ((b - a) / (n - 1))
  step = (b - a) * (1.0 / (n - 1))

  # dtype = :float64 is used to prevent integer coercion.
  result = NVector.seq(n, :float64) * NMatrix.new([n,1], step, dtype: :float64)
  result += NMatrix.new([n,1], a, dtype: :float64)
  result
end

.logspace(a, b, n = 100) ⇒ Object

call-seq: logspace(a, b) -> NVector logspace(a, b, n) -> NVector

Returns a NVector with n values of dtype :float64 logarithmically spaced from 10^a to 10^b, inclusive.

See: http://www.mathworks.com/help/matlab/ref/logspace.html

  • Arguments :
    • a -> The first value in the sequence.
    • b -> The last value in the sequence.
    • n -> The number of elements. Default is 100.
  • Returns :
    • NVector with n :float64 values.

Example:

x = NVector.logspace(0, Math::PI, 10)
x.pretty_print
[1.0
2.2339109164570266
4.990357982665873
11.148015174505757
24.903672795156997
55.632586516975095
124.27824233101062
277.6265222213364
620.1929186882427
1385.4557313670107]

=> nil



1134
1135
1136
1137
1138
1139
1140
 
# File 'lib/nmatrix/shortcuts.rb', line 1134

def logspace(a, b, n = 100)
  # Formula: 10^a, 10^(a + step), ..., 10^b, where step = ((b-a) / (n-1)).

  result = NVector.linspace(a, b, n)
  result.each_stored_with_index { |element, i| result[i] = 10 ** element }
  result
end

.new(*args) ⇒ Object

call-seq: new(shape) -> NVector new(stype, shape) -> NVector new(shape, init) -> NVector new(:dense, shape, init) -> NVector new(:list, shape, init) -> NVector new(shape, init, dtype) -> NVector new(stype, shape, init, dtype) -> NVector new(stype, shape, dtype) -> NVector

Creates a new NVector. See also NMatrix#initialize for a more detailed explanation of the arguments.

  • Arguments :
    • stype -> (optional) Storage type of the vector (:list, :dense, :yale). Defaults to :dense.
    • shape -> Shape of the vector. Accepts [n,1], [1,n], or n, where n is a Fixnum.
    • init -> (optional) Yale: capacity; List: default value (0); Dense: initial value or values (uninitialized by default).
    • dtype -> (optional if init provided) Data type stored in the vector. For :dense and :list, can be inferred from init.

  • Returns :



877
878
879
880
881
882
883
884
885
886
887
888
 
# File 'lib/nmatrix/shortcuts.rb', line 877

def new(*args)
  stype = args[0].is_a?(Symbol) ? args.shift : :dense
  shape = args[0].is_a?(Array) ? args.shift  : [1,args.shift]

  if shape.size != 2 || !shape.include?(1) || shape == [1,1]
    raise(ArgumentError, "shape must be a Fixnum or an Array of positive Fixnums where exactly one value is 1")
  end

  warn "NVector is deprecated and not guaranteed to work any longer"

  NMatrix.new(stype, shape, *args)
end

.ones(size, dtype = :float64) ⇒ Object

call-seq: ones(size) -> NVector ones(size, dtype) -> NVector

Creates a vector of ones with the dimensions supplied as parameters.

  • Arguments :
    • size -> Array (or integer for square matrix) specifying the dimensions.
    • dtype -> (optional) Default is :float64.
  • Returns :
    • NVector filled with ones.

Examples:

NVector.ones(2) # =>  1.0
                    1.0

NVector.ones(3, :int32) # =>  1
                            1
                            1


941
942
943
 
# File 'lib/nmatrix/shortcuts.rb', line 941

def ones(size, dtype = :float64)
  NMatrix.new([size,1], 1, dtype: dtype)
end

.random(size, opts = {}) ⇒ Object

call-seq: random(size) -> NVector

Creates a vector with random numbers between 0 and 1 generated by Random::rand with the dimensions supplied as parameters.

  • Arguments :
    • size -> Array (or integer for square matrix) specifying the dimensions.
    • opts -> (optional) NMatrix#initialize options
  • Returns :
    • NVector filled with random numbers generated by the Random class.

Examples:

NVector.rand(2) # =>  0.4859439730644226
                    0.1783195585012436


963
964
965
966
967
968
969
970
 
# File 'lib/nmatrix/shortcuts.rb', line 963

def random(size, opts = {})
  rng = Random.new

  random_values = []
  size.times { |i| random_values << rng.rand }

  NMatrix.new([size,1], random_values, **opts)
end

.seq(size, dtype = :int64) ⇒ Object

call-seq: seq(n) -> NVector seq(n, dtype) -> NVector

Creates a vector with a sequence of n integers starting at zero. You can choose other types based on the dtype parameter.

  • Arguments :
    • n -> Number of integers in the sequence.
    • dtype -> (optional) Default is :int64.
  • Returns :
    • NVector filled with n integers.

Examples:

NVector.seq(2) # =>  0
                   1

NVector.seq(3, :float32) # =>  0.0
                             1.0
                             2.0


995
996
997
998
999
 
# File 'lib/nmatrix/shortcuts.rb', line 995

def seq(size, dtype = :int64)
  values = (0 ... size).to_a

  NMatrix.new([size,1], values, dtype: dtype)
end

.zeros(size, dtype = :float64) ⇒ Object Also known as: zeroes

call-seq: zeros(size) -> NMatrix zeros(size, dtype) -> NMatrix

Creates a new vector of zeros with the dimensions supplied as parameters.

  • Arguments :
    • size -> Array (or integer for square matrix) specifying the dimensions.
    • dtype -> (optional) Default is :float64.
  • Returns :
    • NVector filled with zeros.

Examples:

NVector.zeros(2) # =>  0.0
                     0.0

NVector.zeros(3, :int32) # =>  0
                             0
                             0


913
914
915
 
# File 'lib/nmatrix/shortcuts.rb', line 913

def zeros(size, dtype = :float64)
  NMatrix.new([size,1], 0, dtype: dtype)
end