nmatrix 0.0.8 → 0.0.9

data/ext/nmatrix/util/sl_list.h

@@ -78,10 +78,15 @@ void	mark(LIST* list, size_t recursions);
 ///////////////
 
 NODE* insert(LIST* list, bool replace, size_t key, void* val);
-NODE* insert_with_copy(LIST *list, size_t key, void *val, size_t size);
+NODE* insert_copy(LIST *list, bool replace, size_t key, void *val, size_t size);
+NODE* insert_first_node(LIST* list, size_t key, void* val, size_t val_size);
+NODE* insert_first_list(LIST* list, size_t key, LIST* l);
 NODE* insert_after(NODE* node, size_t key, void* val);
+NODE* replace_insert_after(NODE* node, size_t key, void* val, bool copy, size_t copy_size);
 void* remove(LIST* list, size_t key);
-bool remove_recursive(LIST* list, const size_t* coords, const size_t* offset, size_t r, const size_t& dim, void* rm);
+void* remove_by_node(LIST* list, NODE* prev, NODE* rm);
+bool remove_recursive(LIST* list, const size_t* coords, const size_t* offset, const size_t* lengths, size_t r, const size_t& dim);
+bool node_is_within_slice(NODE* n, size_t coord, size_t len);
 
 template <typename Type>
 inline NODE* insert_helper(LIST* list, NODE* node, size_t key, Type val) {
@@ -116,7 +121,8 @@ inline NODE* insert_helper(LIST* list, NODE* node, size_t key, Type* ptr) {
 /////////////
 
 NODE* find(LIST* list, size_t key);
-NODE* find_preceding_from(NODE* prev, size_t key);
+NODE* find_preceding_from_node(NODE* prev, size_t key);
+NODE* find_preceding_from_list(LIST* l, size_t key);
 NODE* find_nearest(LIST* list, size_t key);
 NODE* find_nearest_from(NODE* prev, size_t key);
 

data/lib/nmatrix/blas.rb

@@ -85,7 +85,7 @@ module NMatrix::BLAS
         end
 
         n ||= transpose_b ? b.shape[0] : b.shape[1]
-        c		= NMatrix.new([m, n], a.dtype)
+        c		= NMatrix.new([m, n], dtype: a.dtype)
       end
 
       # I think these are independent of whether or not a transpose occurs.
@@ -107,9 +107,9 @@ module NMatrix::BLAS
 
     #
     # call-seq:
-    #     gemv(a, x) -> NVector
-    #     gemv(a, x, y) -> NVector
-    #     gemv(a, x, y, alpha, beta) -> NVector
+    #     gemv(a, x) -> NMatrix
+    #     gemv(a, x, y) -> NMatrix
+    #     gemv(a, x, y, alpha, beta) -> NMatrix
     #
     # Implements matrix-vector product via
     #   y = (alpha * A * x) + (beta * y)
@@ -150,7 +150,7 @@ module NMatrix::BLAS
         beta  = Complex(0.0, 0.0) if beta  == 0.0
       end
 
-      y ||= NMatrix.new([m, n], a.dtype)
+      y ||= NMatrix.new([m, n], dtype: a.dtype)
 
       ::NMatrix::BLAS.cblas_gemv(transpose_a, m, n, alpha, a, lda, x, incx, beta, y, incy)
 
@@ -159,29 +159,29 @@ module NMatrix::BLAS
 
     #
     # call-seq:
-    #     rot(x, y, c, s) -> [NVector, NVector]
+    #     rot(x, y, c, s) -> [NMatrix, NMatrix]
     #
     # Apply plane rotation.
     #
     # * *Arguments* :
-    #   - +x+ -> NVector
-    #   - +y+ -> NVector
+    #   - +x+ -> NMatrix
+    #   - +y+ -> NMatrix
     #   - +c+ -> cosine of the angle of rotation
     #   - +s+ -> sine of the angle of rotation
-    #   - +incx+ -> stride of NVector +x+
-    #   - +incy+ -> stride of NVector +y+
+    #   - +incx+ -> stride of NMatrix +x+
+    #   - +incy+ -> stride of NMatrix +y+
     #   - +n+ -> number of elements to consider in x and y
     #   - +in_place+ -> true if it's okay to modify the supplied +x+ and +y+ parameters directly; false if not. Default is false.
     # * *Returns* :
     #   - Array with the results, in the format [xx, yy]
     # * *Raises* :
-    #   - +ArgumentError+ -> Expected dense NVectors as first two arguments.
+    #   - +ArgumentError+ -> Expected dense NMatrices as first two arguments.
     #   - +ArgumentError+ -> NMatrix dtype mismatch.
     #   - +ArgumentError+ -> Need to supply n for non-standard incx, incy values.
     #
     def rot(x, y, c, s, incx = 1, incy = 1, n = nil, in_place=false)
-      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, '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/incx.abs, y.size/incy.abs].min
@@ -202,7 +202,7 @@ module NMatrix::BLAS
 
     #
     # call-seq:
-    #     rot!(x, y, c, s) -> [NVector, NVector]
+    #     rot!(x, y, c, s) -> [NMatrix, NMatrix]
     #
     # Apply plane rotation directly to +x+ and +y+.
     #
@@ -221,11 +221,11 @@ module NMatrix::BLAS
     # Since the givens rotation includes a square root, integers and rationals are disallowed.
     #
     # * *Arguments* :
-    #   - +ab+ -> NVector with two elements
+    #   - +ab+ -> NMatrix with two elements
     # * *Returns* :
     #   - Array with the results, in the format [cos(theta), sin(theta)]
     # * *Raises* :
-    #   - +ArgumentError+ -> Expected dense NVector of size 2
+    #   - +ArgumentError+ -> Expected dense NMatrix of size 2
     #
     def rotg(ab)
       raise(ArgumentError, "Expected dense NMatrix of shape [2,1] or [1,2]") unless ab.is_a?(NMatrix) && ab.stype == :dense && ab.size == 2
@@ -241,13 +241,13 @@ module NMatrix::BLAS
     # 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 )
+    #   - +x+ -> an NMatrix (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
+    #   - +ArgumentError+ -> Expected dense NMatrix for arg 0
     #   - +RangeError+ -> n out of range
     #
     def asum(x, incx = 1, n = nil)
@@ -264,13 +264,13 @@ module NMatrix::BLAS
     # 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 )
+    #   - +x+ -> an NMatrix (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
+    #   - +ArgumentError+ -> Expected dense NMatrix for arg 0
     #   - +RangeError+ -> n out of range
     #
     def nrm2(x, incx = 1, n = nil)

data/lib/nmatrix/enumerate.rb

@@ -215,7 +215,7 @@ class NMatrix
     first_as_acc = false
 
     if initial then
-      acc = NMatrix.new(new_shape, initial, dtype || self.dtype)
+      acc = NMatrix.new(new_shape, initial, :dtype => dtype || self.dtype)
     else
       each_rank(dimen) do |sub_mat|
         acc = (sub_mat.is_a?(NMatrix) and !dtype.nil? and dtype != self.dtype) ? sub_mat.cast(self.stype, dtype) : sub_mat

data/lib/nmatrix/io/mat5_reader.rb

@@ -293,19 +293,16 @@ module NMatrix::IO::Matlab
 
       #
       # call-seq:
-      #     repacked_indices(to_itype) ->
+      #     repacked_indices ->
       #
       # Unpacks and repacks index data into the appropriate format for NMatrix.
       #
       # If data is already in the appropriate format, does not unpack or
       # repack, just returns directly.
       #
-      def repacked_indices(to_itype)
-        return [row_index.data, column_index.data] if to_itype == :uint32 # No need to re-pack -- already correct
-
-        STDERR.puts "indices: Requesting itype #{to_itype.inspect}"
-        repacked_row_indices = ::NMatrix::IO::Matlab.repack( self.row_index.data, :miINT32, :itype => to_itype )
-        repacked_col_indices = ::NMatrix::IO::Matlab.repack( self.column_index.data, :miINT32, :itype => to_itype )
+      def repacked_indices
+        repacked_row_indices = ::NMatrix::IO::Matlab.repack( self.row_index.data, :miINT32, :itype )
+        repacked_col_indices = ::NMatrix::IO::Matlab.repack( self.column_index.data, :miINT32, :itype )
 
         [repacked_row_indices, repacked_col_indices]
       end
@@ -341,14 +338,11 @@ module NMatrix::IO::Matlab
         when :mxSPARSE
           raise(NotImplementedError, "expected .mat row indices to be of type :miINT32") unless row_index.tag.data_type == :miINT32
           raise(NotImplementedError, "expected .mat column indices to be of type :miINT32") unless column_index.tag.data_type == :miINT32
-
-          to_itype = NMatrix.itype_by_shape(dimensions)
-
           #require 'pry'
           #binding.pry
 
           # MATLAB always uses :miINT32 for indices according to the spec
-          ia_ja                     = repacked_indices(to_itype)
+          ia_ja                     = repacked_indices
           data_str, repacked_dtype  = repacked_data(dtype)
           NMatrix.new(:yale, self.dimensions.reverse, repacked_dtype, ia_ja[0], ia_ja[1], data_str, repacked_dtype)
 
@@ -443,9 +437,9 @@ module NMatrix::IO::Matlab
 
     FIRST_TAG_FIELD_POS = 128
 
-    ####################
-    # Instance Methods #
-    ####################
+    ###################################
+    # Instance Methods for Mat5Reader #
+    ###################################
 
     def initialize(stream, options = {})
       super(stream, options)

data/lib/nmatrix/lapack.rb

@@ -151,9 +151,9 @@ class NMatrix
         # Build up the u and vt matrices
         m, n = matrix.shape
         dtype = matrix.dtype
-        s_matrix = NMatrix.new([1,matrix.shape.min], dtype)
-        u_matrix = NMatrix.new([m,m], dtype)
-        v_matrix = NMatrix.new([n,n], dtype)
+        s_matrix = NMatrix.new([1,matrix.shape.min], dtype: dtype)
+        u_matrix = NMatrix.new([m,m], dtype: dtype)
+        v_matrix = NMatrix.new([n,n], dtype: dtype)
         # test this
         s = gesvd(type, matrix, s_matrix, u_matrix, v_matrix)
 

data/lib/nmatrix/math.rb

@@ -99,9 +99,9 @@ class NMatrix
 
   def alloc_svd_result
     [
-      NMatrix.new(:dense, self.shape[0], self.dtype),
-      NMatrix.new(:dense, [self.shape[0],1], self.dtype),
-      NMatrix.new(:dense, self.shape[1], self.dtype)
+      NMatrix.new(self.shape[0], dtype: self.dtype),
+      NMatrix.new([self.shape[0],1], dtype: self.dtype),
+      NMatrix.new(self.shape[1], dtype: self.dtype)
     ]
   end
 

data/lib/nmatrix/nmatrix.rb

@@ -65,6 +65,13 @@ class NMatrix
     def load_file(file_path)
       NMatrix::IO::Mat5Reader.new(File.open(file_path, 'rb')).to_ruby
     end
+
+    #
+    # Calculate the size of an NMatrix of a given shape.
+    def size(shape)
+      shape = [shape,shape] unless shape.is_a?(Array)
+      (0...shape.size).inject(1) { |x,i| x * shape[i] }
+    end
   end
 
   # TODO: Make this actually pretty.
@@ -76,7 +83,7 @@ class NMatrix
       longest = Array.new(self.shape[1], 0)
       self.each_column.with_index do |col, j|
         col.each do |elem|
-          elem_len   = elem.to_s.size
+          elem_len   = elem.inspect.size
           longest[j] = elem_len if longest[j] < elem_len
         end
       end
@@ -87,7 +94,7 @@ class NMatrix
             q.group(0, "\n  [\n", "  ]\n") do
               layer.each_row.with_index do |row,i|
                 q.group(0, "    [", "]\n") do
-                  q.seplist(self[i,0...self.shape[1],k].to_flat_array, lambda { q.text ", "}, :each_with_index) { |v,j| q.text v.to_s.rjust(longest[j]) }
+                  q.seplist(self[i,0...self.shape[1],k].to_flat_array, lambda { q.text ", "}, :each_with_index) { |v,j| q.text v.inspect.rjust(longest[j]) }
                 end
               end
             end
@@ -97,7 +104,7 @@ class NMatrix
         q.group(0, "\n[\n", "]") do
           self.each_row.with_index do |row,i|
             q.group(1, "  [", "]") do
-              q.seplist(self.dim > 2 ? row.to_a[0] : row.to_a, lambda { q.text ", " }, :each_with_index) { |v,j| q.text v.to_s.rjust(longest[j]) }
+              q.seplist(self.dim > 2 ? row.to_a[0] : row.to_a, lambda { q.text ", " }, :each_with_index) { |v,j| q.text v.inspect.rjust(longest[j]) }
             end
             q.breakable
           end
@@ -258,8 +265,7 @@ class NMatrix
   # Returns the total size of the NMatrix based on its shape.
   #
   def size
-    s = self.shape
-    (0...self.dimensions).inject(1) { |x,i| x * s[i] }
+    NMatrix.size(self.shape)
   end
 
 
@@ -455,6 +461,7 @@ class NMatrix
   #def __list_elementwise_add__ rhs
   #  self.__list_map_merged_stored__(rhs){ |l,r| l+r }.cast(self.stype, NMatrix.upcast(self.dtype, rhs.dtype))
   #end
+protected
 
   def inspect_helper #:nodoc:
     ary = []
@@ -486,6 +493,13 @@ class NMatrix
     end
     ary
   end
+
+
+  # NMatrix constructor helper for sparse matrices. Uses multi-slice-setting to initialize a matrix
+  # with a given array of initial values.
+  def __sparse_initial_set__(ary) #:nodoc:
+    self[0...self.shape[0],0...self.shape[1]] = ary
+  end
 end
 
 require_relative './shortcuts.rb'

data/lib/nmatrix/nvector.rb

@@ -61,6 +61,8 @@ class NVector < NMatrix
       raise(ArgumentError, "shape must be a Fixnum or an Array of positive Fixnums where exactly one value is 1")
     end
 
+    warn "NVector is deprecated"
+
     super(stype, shape, *args)
   end
 

data/lib/nmatrix/shortcuts.rb

@@ -70,7 +70,7 @@ class NMatrix
     #
     #   a = NMatrix[ 1,2,3,4 ]          =>  1.0  2.0  3.0  4.0
     #
-    #   a = NMatrix[ 1,2,3,4, :int32 ]  =>  1  2  3  4
+    #   a = NMatrix[ 1,2,3,4, dtype: :int32 ]  =>  1  2  3  4
     #
     #   a = NMatrix[ [1,2,3], [3,4,5] ] =>  1.0  2.0  3.0
     #                                       3.0  4.0  5.0
@@ -85,7 +85,7 @@ class NMatrix
     #   Ruby array:   a =  [ [1,2,3], [4,5,6] ]
     #
     def [](*params)
-      dtype = params.last.is_a?(Symbol) ? params.pop : nil
+      options = params.last.is_a?(Hash) ? params.pop : {}
 
       # First find the dimensions of the array.
       i = 0
@@ -101,22 +101,22 @@ class NMatrix
       #shape.unshift(1) if shape.size == 1
 
       # Then flatten the array.
-      NMatrix.new(shape, params.flatten, dtype)
+      NMatrix.new(shape, params.flatten, options)
     end
 
     #
     # call-seq:
-    #    zeros(size) -> NMatrix
-    #    zeros(size, dtype) -> NMatrix
-    #    zeros(stype, size, dtype) -> NMatrix
+    #    zeros(shape) -> NMatrix
+    #    zeros(shape, dtype: dtype) -> NMatrix
+    #    zeros(shape, dtype: dtype, stype: stype) -> NMatrix
     #
     # Creates a new matrix of zeros with the dimensions supplied as
     # parameters.
     #
     # * *Arguments* :
-    #   - +stype+ -> (optional) Default is +:dense+.
-    #   - +size+ -> Array (or integer for square matrix) specifying the dimensions.
+    #   - +shape+ -> Array (or integer for square matrix) specifying the dimensions.
     #   - +dtype+ -> (optional) Default is +:float64+
+    #   - +stype+ -> (optional) Default is +:dense+.
     # * *Returns* :
     #   - NMatrix filled with zeros.
     #
@@ -125,30 +125,26 @@ class NMatrix
     #   NMatrix.zeros(2) # =>  0.0   0.0
     #                          0.0   0.0
     #
-    #   NMatrix.zeros([2, 3], :int32) # =>  0  0  0
-    #                                       0  0  0
+    #   NMatrix.zeros([2, 3], dtype: :int32) # =>  0  0  0
+    #                                              0  0  0
     #
-    #   NMatrix.zeros(:list, [1, 5], :int32) # =>  0  0  0  0  0
+    #   NMatrix.zeros([1, 5], dtype: :int32) # =>  0  0  0  0  0
     #
-    def zeros(*params)
-      dtype = params.last.is_a?(Symbol) ? params.pop : :float64
-      stype = params.first.is_a?(Symbol) ? params.shift : :dense
-      dim = params.first
-
-      NMatrix.new(stype, dim, 0, dtype)
+    def zeros(shape, opts = {})
+      NMatrix.new(shape, 0, {:dtype => :float64}.merge(opts))
     end
     alias :zeroes :zeros
 
     #
     # call-seq:
-    #     ones(size) -> NMatrix
-    #     ones(size, dtype) -> NMatrix
+    #     ones(shape) -> NMatrix
+    #     ones(shape, dtype: dtype, stype: stype) -> NMatrix
     #
     # Creates a matrix filled with ones.
     #
     # * *Arguments* :
-    #   - +size+ -> Array (or integer for square matrix) specifying the dimensions.
-    #   - +dtype+ -> (optional) Default is +:float64+
+    #   - +shape+ -> Array (or integer for square matrix) specifying the shape.
+    #   - +opts+ -> (optional) Hash of options from NMatrix#initialize
     # * *Returns* :
     #   - NMatrix filled with ones.
     #
@@ -156,14 +152,11 @@ class NMatrix
     #
     #   NMatrix.ones([1, 3]) # =>  1.0   1.0   1.0
     #
-    #   NMatrix.ones([2, 3], :int32) # =>  1  1  1
-    #                                      1  1  1
+    #   NMatrix.ones([2, 3], dtype: :int32) # =>  1  1  1
+    #                                             1  1  1
     #
-    def ones(*params)
-      dtype = params.last.is_a?(Symbol) ? params.pop : :float64
-      dim = params.first
-
-      NMatrix.new(dim, 1, dtype)
+    def ones(shape, opts={})
+      NMatrix.new(shape, 1, {:dtype => :float64, :default => 1}.merge(opts))
     end
 
     ##
@@ -177,7 +170,7 @@ class NMatrix
     # @return [NMatrix] a new nmatrix filled with ones.
     #
     def ones_like(nm)
-      NMatrix.ones(nm.shape, nm.dtype)
+      NMatrix.ones(nm.shape, dtype: nm.dtype, stype: nm.stype, capacity: nm.capacity, default: 1)
     end
 
     ##
@@ -191,23 +184,23 @@ class NMatrix
     # @return [NMatrix] a new nmatrix filled with zeros.
     #
     def zeros_like(nm)
-      NMatrix.zeros(nm.stype, nm.shape, nm.dtype)
+      NMatrix.zeros(nm.shape, dtype: nm.dtype, stype: nm.stype, capacity: nm.capacity, default: 0)
     end
 
     #
     # call-seq:
-    #     eye(size) -> NMatrix
-    #     eye(size, dtype) -> NMatrix
-    #     eye(stype, size, dtype) -> NMatrix
+    #     eye(shape) -> NMatrix
+    #     eye(shape, dtype: dtype) -> NMatrix
+    #     eye(shape, stype: stype, dtype: dtype) -> NMatrix
     #
     # Creates an identity matrix (square matrix rank 2).
     #
     # * *Arguments* :
-    #   - +stype+ -> (optional) Default is +:dense+.
     #   - +size+ -> Array (or integer for square matrix) specifying the dimensions.
     #   - +dtype+ -> (optional) Default is +:float64+
+    #   - +stype+ -> (optional) Default is +:dense+.
     # * *Returns* :
-    #   - NMatrix filled with zeros.
+    #   - An identity matrix.
     #
     # Examples:
     #
@@ -215,22 +208,17 @@ class NMatrix
     #                          0.0   1.0   0.0
     #                          0.0   0.0   1.0
     #
-    #    NMatrix.eye(3, :int32) # =>   1   0   0
-    #                                  0   1   0
-    #                                  0   0   1
+    #    NMatrix.eye(3, dtype: :int32) # =>   1   0   0
+    #                                         0   1   0
+    #                                         0   0   1
     #
-    #    NMatrix.eye(:yale, 2, :int32) # =>   1   0
-    #                                         0   1
+    #    NMatrix.eye(2, dtype: :int32, stype: :yale) # =>   1   0
+    #                                                       0   1
     #
-    def eye(*params)
-      dtype = params.last.is_a?(Symbol) ? params.pop : :float64
-      stype = params.first.is_a?(Symbol) ? params.shift : :dense
-
-      dim = params.first
-
+    def eye(shape, opts={})
       # Fill the diagonal with 1's.
-      m = NMatrix.zeros(stype, dim, dtype)
-      (0...dim).each do |i|
+      m = NMatrix.zeros(shape, {:dtype => :float64}.merge(opts))
+      (0...m.shape[0]).each do |i|
         m[i, i] = 1
       end
 
@@ -240,16 +228,13 @@ class NMatrix
     #
     # call-seq:
     #     diagonals(array) -> NMatrix
-    #     diagonals(stype, array, dtype) -> NMatrix
-    #     diagonals(array, dtype) -> NMatrix
-    #     diagonals(stype, array) -> NMatrix
+    #     diagonals(array, dtype: dtype, stype: stype) -> NMatrix
     #
     # Creates a matrix filled with specified diagonals.
     #
     # * *Arguments* :
-    #   - +stype+ -> (optional) Storage type for the matrix (default is :dense)
     #   - +entries+ -> Array containing input values for diagonal matrix
-    #   - +dtype+ -> (optional) Default is based on values in supplied Array
+    #   - +options+ -> (optional) Hash with options for NMatrix#initialize
     # * *Returns* :
     #   - NMatrix filled with specified diagonal values.
     #
@@ -260,19 +245,17 @@ class NMatrix
     #                                      0.0 0.0 3.0 0.0
     #                                      0.0 0.0 0.0 4.0
     #
-    #   NMatrix.diagonal(:dense, [1,2,3,4], :int32) # => 1 0 0 0
-    #                                                    0 2 0 0
-    #                                                    0 0 3 0
-    #                                                    0 0 0 4
+    #   NMatrix.diagonal([1,2,3,4], dtype: :int32) # => 1 0 0 0
+    #                                                   0 2 0 0
+    #                                                   0 0 3 0
+    #                                                   0 0 0 4
     #
     #
-    def diagonal(*params)
-      dtype = params.last.is_a?(Symbol) ? params.pop : nil
-      stype = params.first.is_a?(Symbol) ? params.shift : :dense
-      ary   = params.shift
-
-      m = NMatrix.zeros(stype, ary.length, dtype || guess_dtype(ary[0]))
-      ary.each_with_index do |n, i|
+    def diagonal(entries, opts={})
+      m = NMatrix.zeros(entries.size,
+                        {:dtype => guess_dtype(entries[0]), :capacity => entries.size + 1}.merge(opts)
+                       )
+      entries.each_with_index do |n, i|
         m[i,i] = n
       end
       m
@@ -282,141 +265,121 @@ class NMatrix
 
     #
     # call-seq:
-    #     random(size) -> NMatrix
+    #     random(shape) -> NMatrix
     #
     # Creates a +:dense+ NMatrix with random numbers between 0 and 1 generated
     # by +Random::rand+. The parameter is the dimension of the matrix.
     #
     # * *Arguments* :
-    #   - +size+ -> Array (or integer for square matrix) specifying the dimensions.
+    #   - +shape+ -> Array (or integer for square matrix) specifying the dimensions.
     # * *Returns* :
-    #   - NMatrix filled with zeros.
+    #   - NMatrix filled with random values.
     #
     # Examples:
     #
     #   NMatrix.random([2, 2]) # => 0.4859439730644226   0.1783195585012436
     #                               0.23193766176700592  0.4503345191478729
     #
-    def random(size)
+    def random(shape, opts={})
       rng = Random.new
 
       random_values = []
 
       # Construct the values of the final matrix based on the dimension.
-      if size.is_a?(Integer)
-        (size * size - 1).times { |i| random_values << rng.rand }
-      else
-        # Dimensions given by an array. Get the product of the array elements
-        # and generate this number of random values.
-        size.reduce(1, :*).times { |i| random_values << rng.rand }
-      end
+      NMatrix.size(shape).times { |i| random_values << rng.rand }
 
-      NMatrix.new(:dense, size, random_values, :float64)
+      NMatrix.new(shape, random_values, {:dtype => :float64, :stype => :dense}.merge(opts))
     end
 
     #
     # call-seq:
-    #     seq(size) -> NMatrix
-    #     seq(size, dtype) -> NMatrix
+    #     seq(shape) -> NMatrix
+    #     seq(shape, options) -> NMatrix
     #
     # Creates a matrix filled with a sequence of integers starting at zero.
     #
     # * *Arguments* :
-    #   - +size+ -> Array (or integer for square matrix) specifying the dimensions.
-    #   - +dtype+ -> (optional) Default is +:float64+
+    #   - +shape+ -> Array (or integer for square matrix) specifying the dimensions.
+    #   - +options+ -> (optional) Options permissible for NMatrix#initialize
     # * *Returns* :
-    #   - NMatrix filled with zeros.
+    #   - NMatrix filled with values 0 through +size+.
     #
     # Examples:
     #
     #   NMatrix.seq(2) # =>   0   1
     #                 2   3
     #
-    #   NMatrix.seq([3, 3], :float32) # =>  0.0  1.0  2.0
+    #   NMatrix.seq([3, 3], dtype: :float32) # =>  0.0  1.0  2.0
     #                                       3.0  4.0  5.0
     #                                       6.0  7.0  8.0
     #
-    def seq(*params)
-      dtype = params.last.is_a?(Symbol) ? params.pop : nil
-      size = params.first
-
-      # Must provide the dimension as an Integer for a square matrix or as an
-      # 2 element array, e.g. [2,4].
-      unless size.is_a?(Integer) || (size.is_a?(Array) && size.size < 3)
-        raise ArgumentError, "seq() accepts only integers or 2-element arrays \
-as dimension."
-      end
+    def seq(shape, options={})
 
       # Construct the values of the final matrix based on the dimension.
-      if size.is_a?(Integer)
-        values = (0 .. (size * size - 1)).to_a
-      else
-        # Dimensions given by a 2 element array.
-        values = (0 .. (size.first * size.last - 1)).to_a
-      end
+      values = (0 ... NMatrix.size(shape)).to_a
 
       # It'll produce :int32, except if a dtype is provided.
-      NMatrix.new(:dense, size, values, dtype)
+      NMatrix.new(shape, values, {:stype => :dense}.merge(options))
     end
 
     #
     # call-seq:
     #     indgen(size) -> NMatrix
     #
-    # Returns an integer NMatrix. Equivalent to <tt>seq(n, :int32)</tt>.
+    # Returns an integer NMatrix. Equivalent to <tt>seq(n, dtype: :int32)</tt>.
     #
     # * *Arguments* :
-    #   - +size+ -> Size of the sequence.
+    #   - +shape+ -> Shape of the sequence.
     # * *Returns* :
     #   - NMatrix with dtype +:int32+.
     #
-    def indgen(size)
-      NMatrix.seq(size, :int32)
+    def indgen(shape)
+      NMatrix.seq(shape, dtype: :int32)
     end
 
     #
     # call-seq:
-    #     findgen(size) -> NMatrix
+    #     findgen(shape) -> NMatrix
     #
-    # Returns a float NMatrix. Equivalent to <tt>seq(n, :float32)</tt>.
+    # Returns a float NMatrix. Equivalent to <tt>seq(n, dtype: :float32)</tt>.
     #
     # * *Arguments* :
-    #   - +size+ -> Size of the sequence.
+    #   - +shape+ -> Shape of the sequence.
     # * *Returns* :
     #   - NMatrix with dtype +:float32+.
     #
-    def findgen(size)
-      NMatrix.seq(size, :float32)
+    def findgen(shape)
+      NMatrix.seq(shape, dtype: :float32)
     end
 
     #
     # call-seq:
     #     bindgen(size) -> NMatrix
     #
-    # Returns a byte NMatrix. Equivalent to <tt>seq(n, :byte)</tt>.
+    # Returns a byte NMatrix. Equivalent to <tt>seq(n, dtype: :byte)</tt>.
     #
     # * *Arguments* :
-    #   - +size+ -> Size of the sequence.
+    #   - +size+ -> Shape of the sequence.
     # * *Returns* :
     #   - NMatrix with dtype +:byte+.
     #
-    def bindgen(size)
-      NMatrix.seq(size, :byte)
+    def bindgen(shape)
+      NMatrix.seq(shape, dtype: :byte)
     end
 
     #
     # call-seq:
-    #     cindgen(size) -> NMatrix
+    #     cindgen(shape) -> NMatrix
     #
-    # Returns an complex NMatrix. Equivalent to <tt>seq(n, :complex64)</tt>.
+    # Returns a complex NMatrix. Equivalent to <tt>seq(n, dtype: :complex64)</tt>.
     #
     # * *Arguments* :
-    #   - +size+ -> Size of the sequence.
+    #   - +shape+ -> Shape of the sequence.
     # * *Returns* :
     #   - NMatrix with dtype +:complex64+.
     #
-    def cindgen(size)
-      NMatrix.seq(size, :complex64)
+    def cindgen(shape)
+      NMatrix.seq(shape, dtype: :complex64)
     end
 
   end
@@ -455,6 +418,8 @@ module NVector
         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
 
@@ -482,7 +447,7 @@ module NVector
     #                                  0
     #
     def zeros(size, dtype = :float64)
-      NVector.new(size, 0, dtype)
+      NMatrix.new([size,1], 0, dtype: dtype)
     end
     alias :zeroes :zeros
 
@@ -510,7 +475,7 @@ module NVector
     #                                 1
     #
     def ones(size, dtype = :float64)
-      NVector.new(size, 1, dtype)
+      NMatrix.new([size,1], 1, dtype: dtype)
     end
 
     #
@@ -522,7 +487,7 @@ module NVector
     #
     # * *Arguments* :
     #   - +size+ -> Array (or integer for square matrix) specifying the dimensions.
-    #   - +dtype+ -> (optional) Default is +:float64+.
+    #   - +opts+ -> (optional) NMatrix#initialize options
     # * *Returns* :
     #   - NVector filled with random numbers generated by the +Random+ class.
     #
@@ -531,13 +496,13 @@ module NVector
     #   NVector.rand(2) # =>  0.4859439730644226
     #                         0.1783195585012436
     #
-    def random(size)
+    def random(size, opts = {})
       rng = Random.new
 
       random_values = []
       size.times { |i| random_values << rng.rand }
 
-      NVector.new(size, random_values, :float64)
+      NMatrix.new([size,1], random_values, opts)
     end
 
     #
@@ -566,7 +531,7 @@ module NVector
     def seq(size, dtype = :int64)
       values = (0 ... size).to_a
 
-      NVector.new(size, values, dtype)
+      NMatrix.new([size,1], values, dtype: dtype)
     end
 
     #
@@ -665,8 +630,8 @@ module NVector
       step = (b - a) * (1.0 / (n - 1))
 
       # dtype = :float64 is used to prevent integer coercion.
-      result = NVector.seq(n, :float64) * NVector.new(n, step, :float64)
-      result += NVector.new(n, a, :float64)
+      result = NVector.seq(n, :float64) * NMatrix.new([n,1], step, dtype: :float64)
+      result += NMatrix.new([n,1], a, dtype: :float64)
       result
     end