nmatrix 0.0.5 → 0.0.6

data/lib/nmatrix/monkeys.rb

@@ -52,18 +52,6 @@ class Array
 
     if stype != :dense then matrix.cast(stype, dtype) else matrix end
   end
-
-  unless method_defined?(:max)
-    def max #:nodoc:
-      self.inject(self.first) { |m, n| if n > m then n else m end }
-    end
-  end
-
-  unless method_defined?(:min)
-    def min #:nodoc:
-      self.inject(self.first) { |m, n| if n < m then n else m end }
-    end
-  end
 end
 
 class Object #:nodoc:
@@ -72,43 +60,3 @@ class Object #:nodoc:
     value
   end
 end
-
-class String #:nodoc:
-  unless method_defined?(:constantize)
-    # Based on constantize from ActiveSupport::Inflector
-    def constantize
-      names = self.split('::')
-      names.shift if names.empty? || names.first.empty?
-
-      constant = Object
-      names.each do |name|
-        constant = constant.const_defined?(name, false) ? constant.const_get(name) : constant.const_missing(name)
-      end
-      constant
-    end
-  end
-
-  unless method_defined?(:camelize)
-    # Adapted from camelize from ActiveSupport::Inflector
-    def camelize first_letter_in_uppercase = true
-      if first_letter_in_uppercase
-        self.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-      else
-        self.to_s[0].chr.downcase + self[1..-1].camelize
-      end
-    end
-  end
-
-  unless method_defined?(:underscore)
-    # Adapted from underscore from ActiveSupport::Inflector
-    def underscore
-      word = self.dup
-      word.gsub!(/::/, '/')
-      word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
-      word.tr!("-", "_")
-      word.downcase!
-      word
-    end
-  end
-end

data/lib/nmatrix/nmatrix.rb

@@ -82,6 +82,48 @@ class NMatrix
   end
   alias :pp :pretty_print
 
+
+  #
+  # call-seq:
+  #     cast(stype, dtype, default) -> NMatrix
+  #     cast(stype, dtype) -> NMatrix
+  #     cast(stype) -> NMatrix
+  #     cast(options) -> NMatrix
+  #
+  # This is a user-friendly helper for calling #cast_full. The easiest way to call this function is using an
+  # options hash, e.g.,
+  #
+  #     n.cast(:stype => :yale, :dtype => :int64, :default => false)
+  #
+  # For list and yale, :default sets the "default value" or "init" of the matrix. List allows a bit more freedom
+  # since non-zeros are permitted. For yale, unpredictable behavior may result if the value is not false, nil, or
+  # some version of 0. Dense discards :default.
+  #
+  # dtype and stype are inferred from the matrix upon which #cast is called -- so you only really need to provide
+  # one. You can actually call this function with no arguments, in which case it functions like #clone.
+  #
+  # If your dtype is :object and you are converting from :dense to a sparse type, it is recommended that you
+  # provide a :default, as 0 may behave differently from its Float, Rational, or Complex equivalent. If no option
+  # is given, Fixnum 0 will be used.
+  def cast(*params)
+    if (params.size > 0 && params[0].is_a?(Hash))
+      opts = {
+          :stype => self.stype,
+          :dtype => self.dtype,
+          :default => self.stype == :dense ? 0 : self.default_value
+      }.merge(params[0])
+
+      self.cast_full(opts[:stype], opts[:dtype], opts[:default])
+    else
+      params << self.stype if params.size == 0
+      params << self.dtype if params.size == 1
+      params << (self.stype == :dense ? 0 : self.default_value) if params.size == 2
+
+      self.cast_full(*params)
+    end
+
+  end
+
   #
   # call-seq:
   #     rows -> Integer
@@ -122,8 +164,10 @@ class NMatrix
         end
       end
       h
-    else # dense and list should use a C internal functions.
-      to_hash_c
+    else # dense and list should use a C internal function.
+      # FIXME: Write a C internal to_h function.
+      m = stype == :dense ? self.cast(:list, self.dtype) : self
+      m.__list_to_hash__
     end
   end
   alias :to_h :to_hash
@@ -293,6 +337,7 @@ class NMatrix
     '[' + ary.collect { |a| a ? a : 'nil'}.join(',') + ']'
   end
 
+
   ##
   # call-seq:
   #   each_along_dim() -> Enumerator
@@ -317,6 +362,7 @@ class NMatrix
     end
   end
 
+
   ##
   # call-seq:
   #   reduce_along_dim() -> Enumerator
@@ -441,7 +487,7 @@ class NMatrix
   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
+        min * (min <= sub_mat).cast(self.stype, self.dtype) + ((min)*0.0 + (min > sub_mat).cast(self.stype, self.dtype)) * sub_mat
       else
         min <= sub_mat ? min : sub_mat
       end
@@ -460,7 +506,7 @@ class NMatrix
   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
+        max * (max >= sub_mat).cast(self.stype, self.dtype) + ((max)*0.0 + (max < sub_mat).cast(self.stype, self.dtype)) * sub_mat
       else
         max >= sub_mat ? max : sub_mat
       end
@@ -508,7 +554,7 @@ class NMatrix
 
   ##
   # call-seq:
-  #   to_f() -> Float
+  #   to_f -> Float
   #
   # Converts an nmatrix with a single element (but any number of dimensions)
   #  to a float.
@@ -523,8 +569,24 @@ class NMatrix
 
   ##
   # call-seq:
-  #   map() -> Enumerator
-  #   map() { |elem| block } -> NMatrix
+  #   each -> Enumerator
+  #
+  # Enumerate through the matrix. @see Enumerable#each
+  #
+  # For dense, this actually calls a specialized each iterator (in C). For yale and list, it relies upon
+  # #each_with_indices (which is about as fast as reasonably possible for C code).
+  def each &block
+    if self.stype == :dense
+      self.__dense_each__(&block)
+    else
+      self.each_with_indices(&block)
+    end
+  end
+
+  ##
+  # call-seq:
+  #   map -> Enumerator
+  #   map { |elem| block } -> NMatrix
   #
   # @see Enumerable#map
   #
@@ -537,8 +599,8 @@ class NMatrix
 
   ##
   # call-seq:
-  #   map!() -> Enumerator
-  #   map!() { |elem| block } -> NMatrix
+  #   map! -> Enumerator
+  #   map! { |elem| block } -> NMatrix
   #
   # Maps in place.
   # @see #map
@@ -620,7 +682,70 @@ class NMatrix
     end
   end
 
+
+  def method_missing name, *args, &block #:nodoc:
+    if name.to_s =~ /^__list_elementwise_.*__$/
+      raise NotImplementedError, "requested undefined list matrix element-wise operation"
+    elsif name.to_s =~ /^__yale_scalar_.*__$/
+      raise NotImplementedError, "requested undefined yale scalar element-wise operation"
+    else
+      super(name, *args, &block)
+    end
+  end
+
 protected
+  # Define the element-wise operations for lists. Note that the __list_map_merged_stored__ iterator returns a Ruby Object
+  # matrix, which we then cast back to the appropriate type. If you don't want that, you can redefine these functions in
+  # your own code.
+  {add: :+, sub: :-, mul: :*, div: :/, pow: :**, mod: :%}.each_pair do |ewop, op|
+    define_method("__list_elementwise_#{ewop}__") do |rhs|
+      self.__list_map_merged_stored__(rhs, nil) { |l,r| l.send(op,r) }.cast(stype, NMatrix.upcast(dtype, rhs.dtype))
+    end
+    define_method("__dense_elementwise_#{ewop}__") do |rhs|
+      self.__dense_map_pair__(rhs) { |l,r| l.send(op,r) }.cast(stype, NMatrix.upcast(dtype, rhs.dtype))
+    end
+    define_method("__yale_elementwise_#{ewop}__") do |rhs|
+      self.__yale_map_merged_stored__(rhs, nil) { |l,r| l.send(op,r) }.cast(stype, NMatrix.upcast(dtype, rhs.dtype))
+    end
+    define_method("__list_scalar_#{ewop}__") do |rhs|
+      self.__list_map_merged_stored__(rhs, nil) { |l,r| l.send(op,r) }.cast(stype, NMatrix.upcast(dtype, NMatrix.min_dtype(rhs)))
+    end
+    define_method("__yale_scalar_#{ewop}__") do |rhs|
+      self.__yale_map_stored__ { |l| l.send(op,rhs) }.cast(stype, NMatrix.upcast(dtype, NMatrix.min_dtype(rhs)))
+    end
+    define_method("__dense_scalar_#{ewop}__") do |rhs|
+      self.__dense_map__ { |l| l.send(op,rhs) }.cast(stype, NMatrix.upcast(dtype, NMatrix.min_dtype(rhs)))
+    end
+  end
+
+  # Equality operators do not involve a cast. We want to get back matrices of TrueClass and FalseClass.
+  {eqeq: :==, neq: :!=, lt: :<, gt: :>, leq: :<=, geq: :>=}.each_pair do |ewop, op|
+    define_method("__list_elementwise_#{ewop}__") do |rhs|
+      self.__list_map_merged_stored__(rhs, nil) { |l,r| l.send(op,r) }
+    end
+    define_method("__dense_elementwise_#{ewop}__") do |rhs|
+      self.__dense_map_pair__(rhs) { |l,r| l.send(op,r) }
+    end
+    define_method("__yale_elementwise_#{ewop}__") do |rhs|
+      self.__yale_map_merged_stored__(rhs, nil) { |l,r| l.send(op,r) }
+    end
+
+    define_method("__list_scalar_#{ewop}__") do |rhs|
+      self.__list_map_merged_stored__(rhs, nil) { |l,r| l.send(op,r) }
+    end
+    define_method("__yale_scalar_#{ewop}__") do |rhs|
+      self.__yale_map_stored__ { |l| l.send(op,rhs) }
+    end
+    define_method("__dense_scalar_#{ewop}__") do |rhs|
+      self.__dense_map__ { |l| l.send(op,rhs) }
+    end
+  end
+
+  # This is how you write an individual element-wise operation function:
+  #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
+
   def inspect_helper #:nodoc:
     ary = []
     ary << "shape:[#{shape.join(',')}]" << "dtype:#{dtype}" << "stype:#{stype}"
@@ -639,4 +764,6 @@ protected
 
     ary
   end
+
+
 end

data/lib/nmatrix/nvector.rb

@@ -248,6 +248,39 @@ class NVector < NMatrix
     t.shuffle!(*args)
   end
 
+  #
+  # call-seq:
+  #     sorted_indices -> Array
+  #
+  # Returns an array of the indices ordered by value sorted.
+  #
+  def sorted_indices
+    ary = self.to_a
+    ary.each_index.sort_by { |i| ary[i] }  # from: http://stackoverflow.com/a/17841159/170300
+  end
+
+  #
+  # call-seq:
+  #     binned_sorted_indices -> Array
+  #
+  # Returns an array of arrays of indices ordered by value sorted. Functions basically like +sorted_indices+, but
+  # groups indices together for those values that are the same.
+  #
+  def binned_sorted_indices
+    ary = self.to_a
+    ary2 = []
+    last_bin = ary.each_index.sort_by { |i| [ary[i]] }.inject([]) do |result, element|
+      if result.empty? || ary[result[-1]] == ary[element]
+        result << element
+      else
+        ary2 << result
+        [element]
+      end
+    end
+    ary2 << last_bin unless last_bin.empty?
+    ary2
+  end
+
 
   # TODO: Make this actually pretty.
   def pretty_print(q = nil) #:nodoc:

data/lib/nmatrix/shortcuts.rb

@@ -133,7 +133,7 @@ class NMatrix
 
       # Fill the diagonal with 1's.
       m = NMatrix.zeros(stype, dim, dtype)
-      (0 .. (dim - 1)).each do |i|
+      (0...dim).each do |i|
         m[i, i] = 1
       end
 
@@ -141,6 +141,49 @@ class NMatrix
     end
     alias :identity :eye
 
+    #
+    # call-seq:
+    #     diagonals(array) -> NMatrix
+    #     diagonals(stype, array, dtype) -> NMatrix
+    #     diagonals(array, dtype) -> NMatrix
+    #     diagonals(stype, array) -> 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
+    # * *Returns* :
+    #   - NMatrix filled with specified diagonal values.
+    #
+    # Examples:
+    #
+    #   NMatrix.diagonal([1.0,2,3,4]) # => 1.0 0.0 0.0 0.0
+    #                                      0.0 2.0 0.0 0.0
+    #                                      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
+    #
+    #
+    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|
+        m[i,i] = n
+      end
+      m
+    end
+    alias :diag :diagonal
+    alias :diagonals :diagonal
+
     #
     # call-seq:
     #     random(size) -> NMatrix
@@ -527,33 +570,29 @@ class NVector < NMatrix
     # Returns a NVector with +n+ values of dtype +:float64+ equally spaced from
     # +a+ to +b+, inclusive.
     #
-    # Following the MATLAB implementation, if n isn't provided it's assumed to
-    # be 100.
+    # 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.
+    #   - +n+ -> The number of elements. Default is 100.
     # * *Returns* :
-    #   - n-by-1 NMatrix with +n+ +:float64+ values.
+    #   - NVector with +n+ +:float64+ values.
     #
     # Example:
     #   x = NVector.linspace(0, Math::PI, 1000)
-    #   => #<NMatrix:0x007f83921992f0shape:[1000,1] dtype:float64 stype:dense>
-    #
-    #   x.pp
-    #     [0.0]
-    #     [0.0031447373909807737]
-    #     [0.006289474781961547]
+    #   x.pretty_print
+    #     [0.0
+    #     0.0031447373909807737
+    #     0.006289474781961547
     #     ...
-    #     [3.135303178807831]
-    #     [3.138447916198812]
-    #     [3.141592653589793]
+    #     3.135303178807831
+    #     3.138447916198812
+    #     3.141592653589793]
     #   => nil
     #
     def linspace(a, b, n = 100)
-      # See: http://www.mathworks.com/help/matlab/ref/linspace.html
-      # Formula:  seq(n) * step + a
+      # Formula: seq(n) * step + a
 
       # step = ((b - a) / (n - 1))
       step = (b - a) * (1.0 / (n - 1))
@@ -563,6 +602,46 @@ class NVector < NMatrix
       result += NVector.new(n, a, :float64)
       result
     end
+
+    #
+    # 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
+    #
+    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
   end
 end