nmatrix 0.0.4 → 0.0.5

data/lib/nmatrix/blas.rb

@@ -61,9 +61,9 @@ module NMatrix::BLAS
     #   - +ArgumentError+ -> The dtype of the matrices must be equal.
     #
     def gemm(a, b, c = nil, alpha = 1.0, beta = 0.0, transpose_a = false, transpose_b = false, m = nil, n = nil, k = nil, lda = nil, ldb = nil, ldc = nil)
-      raise ArgumentError, 'Expected dense NMatrices as first two arguments.' unless a.is_a?(NMatrix) and b.is_a?(NMatrix) and a.stype == :dense and b.stype == :dense
-      raise ArgumentError, 'Expected nil or dense NMatrix as third argument.' unless c.nil? or (c.is_a?(NMatrix) and c.stype == :dense)
-      raise ArgumentError, 'NMatrix dtype mismatch.'													unless a.dtype == b.dtype and (c ? a.dtype == c.dtype : true)
+      raise(ArgumentError, 'Expected dense NMatrices as first two arguments.') unless a.is_a?(NMatrix) and b.is_a?(NMatrix) and a.stype == :dense and b.stype == :dense
+      raise(ArgumentError, 'Expected nil or dense NMatrix as third argument.') unless c.nil? or (c.is_a?(NMatrix) and c.stype == :dense)
+      raise(ArgumentError, 'NMatrix dtype mismatch.')													 unless a.dtype == b.dtype and (c ? a.dtype == c.dtype : true)
 
       # First, set m, n, and k, which depend on whether we're taking the
       # transpose of a and b.
@@ -133,9 +133,9 @@ module NMatrix::BLAS
     #   - ++ ->
     #
     def gemv(a, x, y = nil, alpha = 1.0, beta = 0.0, transpose_a = false, m = nil, n = nil, lda = nil, incx = nil, incy = nil)
-      raise ArgumentError, 'Expected dense NMatrices as first two arguments.' unless a.is_a?(NMatrix) and x.is_a?(NMatrix) and a.stype == :dense and x.stype == :dense
-      raise ArgumentError, 'Expected nil or dense NMatrix as third argument.' unless y.nil? or (y.is_a?(NMatrix) and y.stype == :dense)
-      raise ArgumentError, 'NMatrix dtype mismatch.'													unless a.dtype == x.dtype and (y ? a.dtype == y.dtype : true)
+      raise(ArgumentError, 'Expected dense NMatrices as first two arguments.') unless a.is_a?(NMatrix) and x.is_a?(NMatrix) and a.stype == :dense and x.stype == :dense
+      raise(ArgumentError, 'Expected nil or dense NMatrix as third argument.') unless y.nil? or (y.is_a?(NMatrix) and y.stype == :dense)
+      raise(ArgumentError, 'NMatrix dtype mismatch.')													 unless a.dtype == x.dtype and (y ? a.dtype == y.dtype : true)
 
       m ||= transpose_a ? a.shape[1] : a.shape[0]
       n ||= transpose_a ? a.shape[0] : a.shape[1]
@@ -179,9 +179,9 @@ module NMatrix::BLAS
     #   - +ArgumentError+ -> Need to supply n for non-standard incx, incy values.
     #
     def rot(x, y, c, s, incx = 1, incy = 1, n = nil)
-      raise ArgumentError, 'Expected dense NMatrices as first two arguments.' unless x.is_a?(NMatrix) and y.is_a?(NMatrix) and x.stype == :dense and y.stype == :dense
-      raise ArgumentError, 'NMatrix dtype mismatch.'													unless x.dtype == y.dtype
-      raise ArgumentError, 'Need to supply n for non-standard incx, incy values' if n.nil? && incx != 1 && incx != -1 && incy != 1 && incy != -1
+      raise(ArgumentError, 'Expected dense NMatrices as first two arguments.') unless x.is_a?(NMatrix) and y.is_a?(NMatrix) and x.stype == :dense and y.stype == :dense
+      raise(ArgumentError, 'NMatrix dtype mismatch.')													unless x.dtype == y.dtype
+      raise(ArgumentError, 'Need to supply n for non-standard incx, incy values') if n.nil? && incx != 1 && incx != -1 && incy != 1 && incy != -1
 
       n ||= x.size > y.size ? y.size : x.size
 
@@ -192,5 +192,51 @@ module NMatrix::BLAS
 
       return [xx,yy]
     end
+
+    #
+    # call-seq:
+    #     asum(x, incx, n)
+    #
+    # Calculate the sum of absolute values of the entries of a vector +x+ of size +n+
+    #
+    # * *Arguments* :
+    #   - +x+ -> an NVector (will also allow an NMatrix, but will treat it as if it's a vector )
+    #   - +incx+ -> the skip size (defaults to 1)
+    #   - +n+ -> the size of +x+ (defaults to +x.size / incx+)
+    # * *Returns* :
+    #   - The sum
+    # * *Raises* :
+    #   - +ArgumentError+ -> Expected dense NVector (or NMatrix on rare occasions) for arg 0
+    #   - +RangeError+ -> n out of range
+    #
+    def asum(x, incx = 1, n = nil)
+      n ||= x.size / incx
+      raise(ArgumentError, "Expected dense NVector (or NMatrix on rare occasions) for arg 0") unless x.is_a?(NMatrix)
+      raise(RangeError, "n out of range") if n*incx > x.size || n*incx <= 0 || n <= 0
+      ::NMatrix::BLAS.cblas_asum(n, x, incx)
+    end
+
+    #
+    # call-seq:
+    #     nrm2(x, incx, n)
+    #
+    # Calculate the 2-norm of a vector +x+ of size +n+
+    #
+    # * *Arguments* :
+    #   - +x+ -> an NVector (will also allow an NMatrix, but will treat it as if it's a vector )
+    #   - +incx+ -> the skip size (defaults to 1)
+    #   - +n+ -> the size of +x+ (defaults to +x.size / incx+)
+    # * *Returns* :
+    #   - The 2-norm
+    # * *Raises* :
+    #   - +ArgumentError+ -> Expected dense NVector (or NMatrix on rare occasions) for arg 0
+    #   - +RangeError+ -> n out of range
+    #
+    def nrm2(x, incx = 1, n = nil)
+      n ||= x.size / incx
+      raise(ArgumentError, "Expected dense NVector (or NMatrix on rare occasions) for arg 0") unless x.is_a?(NMatrix)
+      raise(RangeError, "n out of range") if n*incx > x.size || n*incx <= 0 || n <= 0
+      ::NMatrix::BLAS.cblas_nrm2(n, x, incx)
+    end
   end
 end

data/lib/nmatrix/nmatrix.rb

@@ -29,6 +29,7 @@
 
 require_relative './shortcuts.rb'
 require_relative './lapack.rb'
+require_relative './yale_functions.rb'
 
 class NMatrix
   # Read and write extensions for NMatrix. These are only loaded when needed.
@@ -53,7 +54,7 @@ class NMatrix
   # TODO: Make this actually pretty.
   def pretty_print(q = nil) #:nodoc:
     if dim != 2 || (dim == 2 && shape[1] > 10) # FIXME: Come up with a better way of restricting the display
-      inspect
+      puts self.inspect
     else
 
       arr = (0...shape[0]).map do |i|
@@ -292,6 +293,290 @@ class NMatrix
     '[' + ary.collect { |a| a ? a : 'nil'}.join(',') + ']'
   end
 
+  ##
+  # call-seq:
+  #   each_along_dim() -> Enumerator
+  #   each_along_dim(dimen) -> Enumerator
+  #   each_along_dim() { |elem| block } -> NMatrix
+  #   each_along_dim(dimen) { |elem| block } -> NMatrix
+  #
+  # Successively yields submatrices at each coordinate along a specified
+  # dimension.  Each submatrix will have the same number of dimensions as
+  # the matrix being iterated, but with the specified dimension's size 
+  # equal to 1.
+  #
+  # @param [Integer] dimen the dimension being iterated over.
+  #
+  def each_along_dim(dimen=0)
+    return enum_for(:each_along_dim, dimen) unless block_given?
+    dims = shape
+    shape.each_index { |i| dims[i] = 0...(shape[i]) unless i == dimen }
+    0.upto(shape[dimen]-1) do |i|
+      dims[dimen] = i
+      yield self[*dims]
+    end
+  end
+
+  ##
+  # call-seq:
+  #   reduce_along_dim() -> Enumerator
+  #   reduce_along_dim(dimen) -> Enumerator
+  #   reduce_along_dim(dimen, initial) -> Enumerator
+  #   reduce_along_dim(dimen, initial, dtype) -> Enumerator
+  #   reduce_along_dim() { |elem| block } -> NMatrix
+  #   reduce_along_dim(dimen) { |elem| block } -> NMatrix
+  #   reduce_along_dim(dimen, initial) { |elem| block } -> NMatrix
+  #   reduce_along_dim(dimen, initial, dtype) { |elem| block } -> NMatrix
+  #
+  # Reduces an NMatrix using a supplied block over a specified dimension.
+  # The block should behave the same way as for Enumerable#reduce.
+  #
+  # @param [Integer] dimen the dimension being reduced
+  # @param [Numeric] initial the initial value for the reduction 
+  #  (i.e. the usual parameter to Enumerable#reduce).  Supply nil or do not
+  #  supply this argument to have it follow the usual Enumerable#reduce 
+  #  behavior of using the first element as the initial value.
+  # @param [Symbol] dtype if non-nil/false, forces the accumulated result to have this dtype
+  # @return [NMatrix] an NMatrix with the same number of dimensions as the
+  #  input, but with the input dimension now having size 1.  Each element 
+  #  is the result of the reduction at that position along the specified
+  #  dimension.
+  #
+  def reduce_along_dim(dimen=0, initial=nil, dtype=nil)
+
+    if dimen > shape.size then
+      raise ArgumentError, "Requested dimension does not exist.  Requested: #{dimen}, shape: #{shape}"
+    end
+
+    return enum_for(:reduce_along_dim, dimen, initial) unless block_given?
+
+    new_shape = shape
+    new_shape[dimen] = 1
+
+    first_as_acc = false
+
+    if initial then
+      acc = NMatrix.new(new_shape, initial, dtype || self.dtype)
+    else
+      each_along_dim(dimen) do |sub_mat|
+        if sub_mat.is_a?(NMatrix) and dtype and dtype != self.dtype then
+          acc = sub_mat.cast(self.stype, dtype)
+        else
+          acc = sub_mat
+        end
+        break
+      end
+      first_as_acc = true
+    end
+
+    each_along_dim(dimen) do |sub_mat|
+      if first_as_acc then
+        first_as_acc = false
+        next
+      end
+      acc = (yield acc, sub_mat)
+    end
+
+    acc
+
+  end
+
+  alias_method :inject_along_dim, :reduce_along_dim
+
+  ##
+  # call-seq: 
+  #   integer_dtype?() -> Boolean
+  #
+  # Checks if dtype is an integer type
+  #
+  def integer_dtype?
+    [:byte, :int8, :int16, :int32, :int64].include?(self.dtype)
+  end
+
+  ##
+  # call-seq:
+  #   mean() -> NMatrix
+  #   mean(dimen) -> NMatrix
+  #
+  # Calculates the mean along the specified dimension.
+  #
+  # This will force integer types to float64 dtype.
+  #
+  # @see #reduce_along_dim
+  #
+  def mean(dimen=0)
+    reduce_dtype = nil
+    if integer_dtype? then
+      reduce_dtype = :float64
+    end
+    reduce_along_dim(dimen, 0.0, reduce_dtype) do |mean, sub_mat|
+      mean + sub_mat/shape[dimen]
+    end
+  end
+
+  ##
+  # call-seq:
+  #   sum() -> NMatrix
+  #   sum(dimen) -> NMatrix
+  #
+  # Calculates the sum along the specified dimension.
+  #
+  # @see #reduce_along_dim
+  def sum(dimen=0)
+    reduce_along_dim(dimen, 0.0) do |sum, sub_mat|
+      sum + sub_mat
+    end
+  end
+
+
+  ##
+  # call-seq:
+  #   min() -> NMatrix
+  #   min(dimen) -> NMatrix
+  #
+  # Calculates the minimum along the specified dimension.
+  #
+  # @see #reduce_along_dim
+  #
+  def min(dimen=0)
+    reduce_along_dim(dimen) do |min, sub_mat|
+      if min.is_a? NMatrix then 
+        min * (min <= sub_mat) + ((min)*0.0 + (min > sub_mat)) * sub_mat
+      else
+        min <= sub_mat ? min : sub_mat
+      end
+    end
+  end
+
+  ##
+  # call-seq:
+  #   max() -> NMatrix
+  #   max(dimen) -> NMatrix
+  #
+  # Calculates the maximum along the specified dimension.
+  #
+  # @see #reduce_along_dim
+  #
+  def max(dimen=0)
+    reduce_along_dim(dimen) do |max, sub_mat|
+      if max.is_a? NMatrix then
+        max * (max >= sub_mat) + ((max)*0.0 + (max < sub_mat)) * sub_mat
+      else
+        max >= sub_mat ? max : sub_mat
+      end
+    end
+  end
+
+
+  ##
+  # call-seq:
+  #   variance() -> NMatrix
+  #   variance(dimen) -> NMatrix
+  #
+  # Calculates the sample variance along the specified dimension.
+  #
+  # This will force integer types to float64 dtype.
+  #
+  # @see #reduce_along_dim
+  #
+  def variance(dimen=0)
+    reduce_dtype = nil
+    if integer_dtype? then
+      reduce_dtype = :float64
+    end
+    m = mean(dimen)
+    reduce_along_dim(dimen, 0.0, reduce_dtype) do |var, sub_mat|
+      var + (m - sub_mat)*(m - sub_mat)/(shape[dimen]-1)
+    end
+  end
+
+  ##
+  # call-seq:
+  #   std() -> NMatrix
+  #   std(dimen) -> NMatrix
+  #
+  #
+  # Calculates the sample standard deviation along the specified dimension.
+  #
+  # This will force integer types to float64 dtype.
+  #
+  # @see #reduce_along_dim
+  #
+  def std(dimen=0)
+    variance(dimen).map! { |e| Math.sqrt(e) }
+  end
+
+  ##
+  # call-seq:
+  #   to_f() -> Float
+  #
+  # Converts an nmatrix with a single element (but any number of dimensions)
+  #  to a float.
+  #
+  # Raises an IndexError if the matrix does not have just a single element.
+  #
+  # FIXME: Does this actually happen? Matrices should not have just one element.
+  def to_f
+    raise IndexError, 'to_f only valid for matrices with a single element' unless shape.all? { |e| e == 1 }
+    self[*Array.new(shape.size, 0)]
+  end
+
+  ##
+  # call-seq:
+  #   map() -> Enumerator
+  #   map() { |elem| block } -> NMatrix
+  #
+  # @see Enumerable#map
+  #
+  def map(&bl)
+    return enum_for(:map) unless block_given?
+    cp = self.dup
+    cp.map! &bl
+    cp
+  end
+
+  ##
+  # call-seq:
+  #   map!() -> Enumerator
+  #   map!() { |elem| block } -> NMatrix
+  #
+  # Maps in place.
+  # @see #map
+  #
+  def map!
+    return enum_for(:map!) unless block_given?
+    self.each_stored_with_indices do |e, *i|
+      self[*i] = (yield e)
+    end
+    self
+  end
+
+
+  #
+  # call-seq:
+  #     each_row -> ...
+  #
+  # Iterate through each row, referencing it as an NVector.
+  def each_row(get_by=:reference, &block)
+    (0...self.shape[0]).each do |i|
+      yield self.row(i, get_by)
+    end
+    self
+  end
+
+  #
+  # call-seq:
+  #     each_column -> ...
+  #
+  # Iterate through each column, referencing it as an NVector.
+  def each_row(get_by=:reference, &block)
+    (0...self.shape[0]).each do |i|
+      yield self.row(i, get_by)
+    end
+    self
+  end
+
+
   class << self
     #
     # call-seq:
@@ -305,9 +590,37 @@ class NMatrix
     def load_file(file_path)
       NMatrix::IO::Mat5Reader.new(File.open(file_path, 'rb')).to_ruby
     end
+
+    ##
+    # call-seq:
+    #   ones_like(nm) -> NMatrix
+    #
+    # Creates a new matrix of ones with the same dtype and shape as the
+    # provided matrix.
+    #
+    # @param [NMatrix] nm the nmatrix whose dtype and shape will be used
+    # @return [NMatrix] a new nmatrix filled with ones.
+    #
+    def ones_like(nm)
+      NMatrix.ones(nm.shape, nm.dtype)
+    end
+
+    ##
+    # call-seq:
+    #   zeros_like(nm) -> NMatrix
+    #
+    # Creates a new matrix of zeros with the same stype, dtype, and shape
+    # as the provided matrix.
+    #
+    # @param [NMatrix] nm the nmatrix whose stype, dtype, and shape will be used
+    # @return [NMatrix] a new nmatrix filled with zeros.
+    #
+    def zeros_like(nm)
+      NMatrix.zeros(nm.stype, nm.shape, nm.dtype)
+    end
   end
 
-  protected
+protected
   def inspect_helper #:nodoc:
     ary = []
     ary << "shape:[#{shape.join(',')}]" << "dtype:#{dtype}" << "stype:#{stype}"

data/lib/nmatrix/nvector.rb

@@ -28,151 +28,232 @@
 
 # This is a specific type of NMatrix in which only one dimension is not 1.
 # Although it is stored as a dim-2, n x 1, matrix, it acts as a dim-1 vector
-# of size n. If the @orientation flag is set to :row, it is stored as 1 x n
-# instead of n x 1.
+# of size n. If the @orientation flag is set to :column, it is stored as n x 1
+# instead of 1 x n.
 class NVector < NMatrix
   #
   # call-seq:
-  #     new(length) -> NVector
-  #     new(length, values) -> NVector
-  #     new(length, values, dtype) -> NVector
-  #
-  # Creates a new NVector.
+  #     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* :
-  #   - +length+ -> Size of the vector.
-  #   - +values+ -> (optional) Initial values of the vector. Default is 0.
-  #   - +dtype+ -> (optional) Default is a guess from the +values+.
+  #   - +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* :
   #   -
   #
-  def initialize(length, *args)
-    super(:dense, [length, 1], *args)
-    orientation
+  def initialize(*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
+
+    super(stype, shape, *args)
   end
 
+
   #
   # call-seq:
   #     orientation -> Symbol
   #
-  # Orientation defaults to column (e.g., [3,1] is a column of length 3). It
-  # may also be row, e.g., for [1,5].
+  # Orientation defaults to row (e.g., [1,3] is a row of length 3). It
+  # may also be column, e.g., for [5,1].
   #
   def orientation
-    @orientation ||= :column
+    shape[0] == 1 ? :row : :column
   end
 
+  # Override NMatrix#each_row and #each_column
+  def each_column(get_by=:reference, &block) #:nodoc:
+    shape[0] == 1 ? self.each(&block) : (yield self)
+  end
+  def each_row(get_by=:reference, &block) #:nodoc:
+    shape[0] == 1 ? (yield self) : self.each(&block)
+  end
+
+
+
   #
   # call-seq:
-  #     transpose -> NVector
+  #     vector[index] -> element
+  #     vector[range] -> NVector
   #
-  # Returns a transposed copy of the vector.
+  # Retrieves an element or return a slice.
   #
-  # * *Returns* :
-  #   - NVector containing the transposed vector.
+  # Examples:
   #
-  def transpose
-    t = super()
-    t.flip!
+  #   u = NVector.new(3, [10, 20, 30])
+  #   u[0]              # => 10
+  #   u[0] + u[1]       # => 30
+  #   u[0 .. 1].shape   # => [2, 1]
+  #
+  def [](i)
+    shape[0] == 1 ? super(0, i) : super(i, 0)
   end
 
   #
   # call-seq:
-  #     transpose! -> NVector
-  #
-  # Transpose the vector in-place.
+  #     vector[index] = obj -> obj
   #
-  # * *Returns* :
-  #   - NVector containing the transposed vector.
+  # Stores +value+ at position +index+.
   #
-  def transpose!
-    super()
-    self.flip!
+  def []=(i, val)
+    shape[0] == 1 ? super(0, i, val) : super(i, 0, val)
   end
 
   #
   # call-seq:
-  #     multiply(m) ->
+  #     dim -> 1
   #
-  # ...
+  # Returns the dimension of a vector, which is 1.
   #
-  # * *Arguments* :
-  #   - ++ ->
-  # * *Returns* :
-  #   -
+  def dim; 1; end
+
   #
-  def multiply(m)
-    t = super(m)
-    t.flip!
+  # call-seq:
+  #     size -> Fixnum
+  #
+  # Shorthand for the dominant shape component
+  def size
+    shape[0] > 1 ? shape[0] : shape[1]
   end
 
   #
   # call-seq:
-  #     multiply!(m) ->
+  #     max -> Numeric
   #
-  # ...
+  # Return the maximum element.
+  def max
+    max_so_far = self[0]
+    self.each do |x|
+      max_so_far = x if x > max_so_far
+    end
+    max_so_far
+  end
+
   #
-  # * *Arguments* :
-  #   - ++ ->
-  # * *Returns* :
-  #   -
+  # call-seq:
+  #     min -> Numeric
   #
-  def multiply!(m)
-    super().flip!
+  # Return the minimum element.
+  def min
+    min_so_far = self[0]
+    self.each do |x|
+      min_so_far = x if x < min_so_far
+    end
+    min_so_far
   end
 
   #
   # call-seq:
-  #     vector[index] -> element
-  #     vector[range] -> NVector
+  #     absolute_sum -> Numeric
   #
-  # Retrieves an element or return a slice.
+  # == Arguments
+  #   - +incx+ -> the skip size (defaults to 1, no skip)
+  #   - +n+ -> the number of elements to include
   #
-  # Examples:
+  # Return the sum of the contents of the vector. This is the BLAS asum routine.
+  def asum incx=1, n=nil
+    NMatrix::BLAS::asum(self, incx, self.size / incx)
+  end
+  alias :absolute_sum :asum
+
   #
-  #   u = NVector.new(3, [10, 20, 30])
-  #   u[0]              # => 10
-  #   u[0] + u[1]       # => 30
-  #   u[0 .. 1].shape   # => [2, 1]
+  # call-seq:
+  #     norm2 -> Numeric
   #
-  def [](i)
-    case @orientation
-    when :column;	super(i, 0)
-    when :row;	  super(0, i)
+  # == Arguments
+  #   - +incx+ -> the skip size (defaults to 1, no skip)
+  #   - +n+ -> the number of elements to include
+  #
+  # Return the 2-norm of the vector. This is the BLAS nrm2 routine.
+  def nrm2 incx=1, n=nil
+    NMatrix::BLAS::nrm2(self, incx, self.size / incx)
+  end
+  alias :norm2 :nrm2
+
+  #
+  # call-seq:
+  #     to_a -> Array
+  #
+  # Converts the NVector to a regular Ruby Array.
+  def to_a
+    if self.stype == :dense
+      ary = Array.new(size)
+      self.each.with_index { |v,idx| ary[idx] = v }
+    else
+      begin
+        ary = Array.new(size, self[0] - self[0]) # Fill the Array with 0s of the appropriate class
+      rescue NoMethodError  # handle Ruby Object arrays that might have nils instead of 0s
+        ary = Array.new(size)
+      end
+      self.each_stored_with_index { |v,idx| ary[idx] = v }
     end
+    ary
   end
 
   #
   # call-seq:
-  #     vector[index] = obj -> obj
+  #     each_stored_with_index -> Enumerator
   #
-  # Stores +value+ at position +index+.
+  # Allow iteration across an NVector's stored values. See also NMatrix#each_stored_with_indices
   #
-  def []=(i, val)
-    case @orientation
-    when :column;	super(i, 0, val)
-    when :row;	  super(0, i, val)
+  def each_stored_with_index(&block)
+    return enum_for(:each_stored_with_index) unless block_given?
+    self.each_stored_with_indices do |v, i, j|
+      shape[0] == 1 ? yield(v,j) : yield(v,i)
     end
+    self
   end
 
   #
   # call-seq:
-  #     dim -> 1
+  #     shuffle! -> ...
+  #     shuffle!(random: rng) -> ...
   #
-  # Returns the dimension of a vector, which is 1.
+  # Re-arranges the contents of an NVector.
   #
-  def dim; 1; end
+  # TODO: Write more efficient version for Yale, list.
+  def shuffle!(*args)
+    ary = self.to_a
+    ary.shuffle!(*args)
+    ary.each.with_index { |v,idx| self[idx] = v }
+    self
+  end
 
-  # shorthand for the dominant shape component
-  def size
-    shape[0] > 1 ? shape[0] : shape[1]
+
+  #
+  # call-seq:
+  #     shuffle -> ...
+  #     shuffle(rng) -> ...
+  #
+  # Re-arranges the contents of an NVector.
+  #
+  # TODO: Write more efficient version for Yale, list.
+  def shuffle(*args)
+    t = self.clone
+    t.shuffle!(*args)
   end
 
+
   # TODO: Make this actually pretty.
   def pretty_print(q = nil) #:nodoc:
-    dim = @orientation == :row ? 1 : 0
+    dimen = shape[0] == 1 ? 1 : 0
 
-    arr = (0...shape[dim]).inject(Array.new){ |a, i| a << self[i] }
+    arr = (0...shape[dimen]).inject(Array.new){ |a, i| a << self[i] }
 
     if q.nil?
       puts "[" + arr.join("\n") + "]"
@@ -186,27 +267,7 @@ class NVector < NMatrix
   def inspect #:nodoc:
     original_inspect = super()
     original_inspect = original_inspect[0...original_inspect.size-1]
-    original_inspect.gsub("@orientation=:#{self.orientation}", "orientation:#{self.orientation}") + ">"
+    original_inspect += " orientation:#{self.orientation}>"
   end
 
-protected
-#  def inspect_helper #:nodoc:
-#    x = (super() << "orientation:#{self.orientation}") #.gsub(" @orientation=:#{self.orientation}", "")
-#    binding.pry
-#    x
-#  end
-
-  #
-  # call-seq:
-  #     flip_orientation! -> NVector
-  #
-  # Flip the orientation of the vector.
-  #
-  # * *Returns* :
-  #   - NVector with orientation changed.
-  #
-  def flip_orientation!
-    returning(self) { @orientation = @orientation == :row ? :column : :row }
-  end
-  alias :flip! :flip_orientation!
 end