nmatrix 0.0.6 → 0.0.7

data/lib/nmatrix/nvector.rb

@@ -185,68 +185,6 @@ class NVector < NMatrix
   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:
-  #     each_stored_with_index -> Enumerator
-  #
-  # Allow iteration across an NVector's stored values. See also NMatrix#each_stored_with_indices
-  #
-  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:
-  #     shuffle! -> ...
-  #     shuffle!(random: rng) -> ...
-  #
-  # Re-arranges the contents of an NVector.
-  #
-  # 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
-
-
-  #
-  # 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
 
   #
   # call-seq:

data/lib/nmatrix/rspec.rb

@@ -0,0 +1,75 @@
+# = NMatrix
+#
+# A linear algebra library for scientific computation in Ruby.
+# NMatrix is part of SciRuby.
+#
+# NMatrix was originally inspired by and derived from NArray, by
+# Masahiro Tanaka: http://narray.rubyforge.org
+#
+# == Copyright Information
+#
+# SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012, Ruby Science Foundation
+#
+# Please see LICENSE.txt for additional copyright notices.
+#
+# == Contributing
+#
+# By contributing source code to SciRuby, you agree to be bound by
+# our Contributor Agreement:
+#
+# * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+#
+# == rspec.rb
+#
+# Monkey patches for RSpec improving its ability to work well with
+# NMatrix (particularly #be_within).
+#
+
+require 'rspec'
+
+# Amend RSpec to allow #be_within for matrices.
+module RSpec::Matchers::BuiltIn #:nodoc:
+  class BeWithin
+
+    def of(expected)
+      @expected = expected
+      @unit     = ''
+      if expected.is_a?(NMatrix)
+        @tolerance = if @delta.is_a?(NMatrix)
+                       @delta.abs
+                     elsif @delta.is_a?(Array)
+                       NMatrix.new(:dense, expected.shape, @delta, :object).abs.cast(:dtype => expected.abs_dtype)
+                     else
+                       (NMatrix.ones_like(expected) * @delta).abs
+                     end
+      else
+        @tolerance = @delta
+      end
+
+      self
+    end
+
+    def percent_of(expected)
+      @expected  = expected
+      @unit      = '%'
+      @tolerance = @expected.abs * @delta / 100.0 # <- only change is to reverse abs and @delta
+      self
+    end
+
+    def matches?(actual)
+      @actual = actual
+      raise needs_expected     unless defined? @expected
+      raise needs_subtractable unless @actual.respond_to? :-
+      res = (@actual - @expected).abs <= @tolerance
+
+      #if res.is_a?(NMatrix)
+      #  require 'pry'
+      #  binding.pry
+      #end
+
+      res.is_a?(NMatrix) ? !res.any? { |x| !x } : res
+    end
+
+  end
+end

data/lib/nmatrix/shortcuts.rb

@@ -34,7 +34,76 @@
 
 class NMatrix
 
+
+
+  #
+  # call-seq:
+  #     dense? -> true or false
+  #     list? -> true or false
+  #     yale? -> true or false
+  #
+  # Shortcut functions for quickly determining a matrix's stype.
+  #
+  def dense?; return stype == :dense; end
+  def yale?;  return stype == :yale;  end
+  def list?;  return stype == :list;  end
+
+
   class << self
+    #
+    # call-seq:
+    #     NMatrix[array-of-arrays, dtype = nil]
+    #
+    # You can use the old +N+ constant in this way:
+    #   N = NMatrix
+    #   N[1, 2, 3]
+    # NMatrix needs to have a succinct way to create a matrix by specifying the
+    # components directly. This is very useful for using it as an advanced
+    # calculator, it is useful for learning how to use, for testing language
+    # features and for developing algorithms.
+    #
+    # The NMatrix::[] method provides a way to create a matrix in a way that is compact and
+    # natural. The components are specified using Ruby array syntax. Optionally,
+    # one can specify a dtype as the last parameter (default is :float64).
+    #
+    # Examples:
+    #
+    #   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], [3,4,5] ] =>  1.0  2.0  3.0
+    #                                       3.0  4.0  5.0
+    #
+    # SYNTAX COMPARISON:
+    #
+    #   MATLAB:		a = [ [1 2 3] ; [4 5 6] ]   or  [ 1 2 3 ; 4 5 6 ]
+    #   IDL:			a = [ [1,2,3] , [4,5,6] ]
+    #   NumPy:		a = array( [1,2,3], [4,5,6] )
+    #
+    #   SciRuby:      a = NMatrix[ [1,2,3], [4,5,6] ]
+    #   Ruby array:   a =  [ [1,2,3], [4,5,6] ]
+    #
+    def [](*params)
+      dtype = params.last.is_a?(Symbol) ? params.pop : nil
+
+      # First find the dimensions of the array.
+      i = 0
+      shape = []
+      row = params
+      while row.is_a?(Array)
+        shape[i] = row.length
+        row = row[0]
+        i += 1
+      end
+
+      # A row vector should be stored as 1xN, not N
+      #shape.unshift(1) if shape.size == 1
+
+      # Then flatten the array.
+      NMatrix.new(shape, params.flatten, dtype)
+    end
+
     #
     # call-seq:
     #    zeros(size) -> NMatrix
@@ -97,6 +166,34 @@ class NMatrix
       NMatrix.new(dim, 1, dtype)
     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
+
     #
     # call-seq:
     #     eye(size) -> NMatrix
@@ -140,7 +237,6 @@ class NMatrix
       m
     end
     alias :identity :eye
-
     #
     # call-seq:
     #     diagonals(array) -> NMatrix
@@ -324,75 +420,50 @@ as dimension."
     end
 
   end
+end
 
-  #
-  # call-seq:
-  #     column(column_number) -> NMatrix
-  #     column(column_number, get_by) -> NMatrix
-  #
-  # Returns the column specified. Uses slicing by copy as default.
-  #
-  # * *Arguments* :
-  #   - +column_number+ -> Integer.
-  #   - +get_by+ -> Type of slicing to use, +:copy+ or +:reference+.
-  # * *Returns* :
-  #   - A NMatrix representing the requested column as a column vector.
-  #
-  # Examples:
-  #
-  #   m = NMatrix.new(2, [1, 4, 9, 14], :int32) # =>  1   4
-  #                                                   9  14
-  #
-  #   m.column(1) # =>   4
-  #                     14
-  #
-  def column(column_number, get_by = :copy)
-    unless [:copy, :reference].include?(get_by)
-      raise ArgumentError, "column() 2nd parameter must be :copy or :reference"
-    end
-
-    if get_by == :copy
-      self.slice(0 ... self.shape[0], column_number)
-    else # by reference
-      self[0 ... self.shape[0], column_number]
-    end
-  end
+module NVector
 
-  alias :col :column
+  class << self
+    #
+    # 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* :
+    #   -
+    #
+    def new(*args)
+      stype = args[0].is_a?(Symbol) ? args.shift : :dense
+      shape = args[0].is_a?(Array) ? args.shift  : [1,args.shift]
 
-  #
-  # call-seq:
-  #     row(row_number) -> NMatrix
-  #     row(row_number, get_by) -> NMatrix
-  #
-  # * *Arguments* :
-  #   - +row_number+ -> Integer.
-  #   - +get_by+ -> Type of slicing to use, +:copy+ or +:reference+.
-  # * *Returns* :
-  #   - A NMatrix representing the requested row .
-  #
-  def row(row_number, get_by = :copy)
-    unless [:copy, :reference].include?(get_by)
-      raise ArgumentError, "row() 2nd parameter must be :copy or :reference"
-    end
+      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
 
-    if get_by == :copy
-      self.slice(row_number, 0 ... self.shape[1])
-    else # by reference
-      self[row_number, 0 ... self.shape[1]]
+      NMatrix.new(stype, shape, *args)
     end
-  end
-end
-
-class NVector < NMatrix
 
-  class << self
     #
     # call-seq:
     #     zeros(size) -> NMatrix
     #     zeros(size, dtype) -> NMatrix
     #
-    # Creates a new matrix of zeros with the dimensions supplied as
+    # Creates a new vector of zeros with the dimensions supplied as
     # parameters.
     #
     # * *Arguments* :
@@ -492,14 +563,10 @@ class NVector < NMatrix
     #                                  1.0
     #                                  2.0
     #
-    def seq(n, dtype = :int64)
-      unless n.is_a?(Integer)
-        raise ArgumentError, "NVector::seq() only accepts integers as size."
-      end
+    def seq(size, dtype = :int64)
+      values = (0 ... size).to_a
 
-      values = (0 ... n).to_a
-
-      NVector.new(n, values, dtype)
+      NVector.new(size, values, dtype)
     end
 
     #
@@ -645,15 +712,8 @@ class NVector < NMatrix
   end
 end
 
-# NMatrix needs to have a succinct way to create a matrix by specifying the
-# components directly. This is very useful for using it as an advanced
-# calculator, it is useful for learning how to use, for testing language
-# features and for developing algorithms.
-#
-# The N class provides a way to create a matrix in a way that is compact and
-# natural. The components are specified using Ruby array syntax. Optionally,
-# one can specify a dtype as the last parameter (default is :float64).
-#
+
+# Use this constant as you would use NMatrix[].
 # Examples:
 #
 #   a = N[ 1,2,3,4 ]          =>  1.0  2.0  3.0  4.0
@@ -663,36 +723,4 @@ end
 #   a = N[ [1,2,3], [3,4,5] ] =>  1.0  2.0  3.0
 #                                 3.0  4.0  5.0
 #
-# SYNTAX COMPARISON:
-#
-#   MATLAB:		a = [ [1 2 3] ; [4 5 6] ]   or  [ 1 2 3 ; 4 5 6 ]
-#   IDL:			a = [ [1,2,3] , [4,5,6] ]
-#   NumPy:		a = array( [1,2,3], [4,5,6] )
-#
-#   SciRuby:      a = N[ [1,2,3], [4,5,6] ]
-#   Ruby array:   a =  [ [1,2,3], [4,5,6] ]
-#
-class N
-  class << self
-    #
-    # call-seq:
-    #     N[array-of-arrays, dtype = nil]
-    #
-    def [](*params)
-      dtype = params.last.is_a?(Symbol) ? params.pop : nil
-
-      # First find the dimensions of the array.
-      i = 0
-      dim = []
-      foo = params
-      while foo.is_a?(Array)
-        dim[i] = foo.length
-        foo = foo[0]
-        i += 1
-      end
-
-      # Then flatten the array.
-      NMatrix.new(dim, params.flatten, dtype)
-    end
-  end
-end
+N = NMatrix

data/lib/nmatrix/version.rb

@@ -26,6 +26,6 @@ class NMatrix
   # Note that the format of the VERSION string is needed for NMatrix
   # native IO. If you change the format, please make sure that native
   # IO can still understand NMatrix::VERSION.
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end