nmatrix 0.1.0.rc5 → 0.1.0

data/lib/nmatrix/io/mat_reader.rb

@@ -30,13 +30,12 @@
 require 'packable'
 
 module NMatrix::IO::Matlab
-  #
+
   # Class for parsing a .mat file stream.
   #
   # The full format of .mat files is available here:
   # * http://www.mathworks.com/help/pdf_doc/matlab/matfile_format.pdf
-  #
-  class MatReader
+  class MatReader #:nodoc:
     MDTYPE_UNPACK_ARGS = {
       :miINT8   => [Integer, {:signed    => true,    :bytes => 1}],
       :miUINT8  => [Integer, {:signed    => false,   :bytes => 1}],
@@ -146,7 +145,7 @@ module NMatrix::IO::Matlab
 
     attr_reader :byte_order
 
-    #
+
     # call-seq:
     #     new(stream, options = {}) -> MatReader
     #
@@ -160,7 +159,6 @@ module NMatrix::IO::Matlab
       @byte_order = options[:byte_order] || guess_byte_order
     end
 
-    #
     # call-seq:
     #     guess_byte_order -> Symbol
     #

data/lib/nmatrix/io/point_cloud.rb

@@ -27,15 +27,34 @@
 #
 #++
 
-# Reader for a PCD file, specified here:
+# Reader for Point Cloud Data (PCD) file format.
 #
-# * http://pointclouds.org/documentation/tutorials/pcd_file_format.php
+# The documentation of this format can be found in:
 #
-# Note that this does not take the width or height parameters into account.
+# http://pointclouds.org/documentation/tutorials/pcd_file_format.php
 #
+# Note that this implementation does not take the width or height parameters
+# into account.
 module NMatrix::IO::PointCloud
 
-  class MetaReader
+  # For UINT, just add 1 to the index.
+  INT_DTYPE_BY_SIZE   = [:int8, :int8, :int16, :int32, :int64, :int64] #:nodoc:
+  FLOAT_DTYPE_BY_SIZE = {4 => :float32, 8 => :float64} #:nodoc:
+
+  class << self
+    # call-seq:
+    #     load(filename) -> NMatrix
+    #
+    # * *Arguments* :
+    #   - +filename+ -> String giving the name of the file to be loaded.
+    #
+    # Load a Point Cloud Library PCD file as a matrix.
+    def load(filename)
+      MetaReader.new(filename).matrix
+    end
+  end
+
+  class MetaReader #:nodoc:
     ENTRIES = [:version,  :fields,           :size,  :type,            :count,  :width,  :height,  :viewpoint,  :points,  :data]
     ASSIGNS = [:version=, :fields=,          :size=, :type=,           :count=, :width=, :height=, :viewpoint=, :points=, :data=]
     CONVERT = [:to_s,     :downcase_to_sym,  :to_i,  :downcase_to_sym, :to_i,   :to_i,   :to_i,    :to_f,       :to_i,    :downcase_to_sym]
@@ -49,7 +68,7 @@ module NMatrix::IO::PointCloud
     class << self
 
       # Given a type and a number of bytes, figure out an appropriate dtype
-      def dtype_by_type_and_size t, s #:nodoc:
+      def dtype_by_type_and_size t, s
         if t == :f
           FLOAT_DTYPE_BY_SIZE[s]
         elsif t == :u
@@ -104,7 +123,7 @@ module NMatrix::IO::PointCloud
 
   protected
     # Read the current entry of the header.
-    def read_entry f, entry, assign=nil, convert=nil #:nodoc:
+    def read_entry f, entry, assign=nil, convert=nil
       assign ||= (entry.to_s + "=").to_sym
 
       while line = f.gets
@@ -133,7 +152,7 @@ module NMatrix::IO::PointCloud
 
     # Determine the dtype for a matrix based on the types and sizes given in the PCD.
     # Call this only after read_entry has been called.
-    def dtype #:nodoc:
+    def dtype
       @dtype ||= begin
         dtypes = self.type.map.with_index do |t,k|
           MetaReader.dtype_by_type_and_size(t, size[k])
@@ -158,25 +177,5 @@ module NMatrix::IO::PointCloud
           self.fields.size
       ]
     end
-
-  end
-
-    # For UINT, just add 1 to the index.
-    INT_DTYPE_BY_SIZE   = [:int8, :int8, :int16, :int32, :int64, :int64]
-    FLOAT_DTYPE_BY_SIZE = {4 => :float32, 8 => :float64}
-
-  class << self
-
-    #
-    # call-seq:
-    #     load(filename) -> NMatrix
-    #
-    # * *Arguments* :
-    #   - +filename+ -> String giving the name of the file to be loaded.
-    #
-    # Load a Point Cloud Library PCD file as a matrix.
-    def load(filename)
-      MetaReader.new(filename).matrix
-    end
   end
-end
+end

data/lib/nmatrix/lapack.rb

@@ -168,7 +168,9 @@ class NMatrix
       # Optionally accepts a +workspace_size+ parameter, which will be honored only if it is larger than what LAPACK
       # requires.
       #
-      def gesdd(matrix, workspace_size=100000)
+      def gesdd(matrix, workspace_size=nil)
+        min_workspace_size = matrix.shape.min * (6 + 4 * matrix.shape.min) + matrix.shape.max
+        workspace_size = min_workspace_size if workspace_size.nil? || workspace_size < min_workspace_size
         result = alloc_svd_result(matrix)
         NMatrix::LAPACK::lapack_gesdd(:a, matrix.shape[0], matrix.shape[1], matrix, matrix.shape[0], result[1], result[0], matrix.shape[0], result[2], matrix.shape[1], workspace_size)
         result

data/lib/nmatrix/math.rb

@@ -30,7 +30,7 @@
 
 class NMatrix
 
-  module NMMath
+  module NMMath #:nodoc:
     METHODS_ARITY_2 = [:atan2, :ldexp, :hypot]
     METHODS_ARITY_1 = [:cos, :sin, :tan, :acos, :asin, :atan, :cosh, :sinh, :tanh, :acosh,
       :asinh, :atanh, :exp, :log2, :log10, :sqrt, :cbrt, :erf, :erfc, :gamma, :-@]
@@ -40,48 +40,65 @@ class NMatrix
   # call-seq:
   #     invert! -> NMatrix
   #
-  # Use LAPACK to calculate the inverse of the matrix (in-place). Only works on
-  # dense matrices.
-  #
-  # Note: If you don't have LAPACK, e.g., on a Mac, this may not work yet. Use
-  # invert instead (which still probably won't work if your matrix is larger than 3x3).
+  # Use LAPACK to calculate the inverse of the matrix (in-place) if available. 
+  # Only works on dense matrices. Alternatively uses in-place Gauss-Jordan 
+  # elimination.
   #
   def invert!
-    # Get the pivot array; factor the matrix
-    pivot = self.getrf!
+    if NMatrix.has_clapack?
+      # Get the pivot array; factor the matrix
+      pivot = self.getrf!
 
-    # Now calculate the inverse using the pivot array
-    NMatrix::LAPACK::clapack_getri(:row, self.shape[1], self, self.shape[1], pivot)
+      # Now calculate the inverse using the pivot array
+      NMatrix::LAPACK::clapack_getri(:row, self.shape[1], self, self.shape[1], pivot)
 
-    self
+      self
+    else
+      if self.integer_dtype?
+        __inverse__(self.cast(dtype: :rational128), true)
+      else
+        dtype = self.dtype
+        __inverse__(self, true)
+      end
+    end
   end
 
   #
   # call-seq:
   #     invert -> NMatrix
   #
-  # Make a copy of the matrix, then invert it (requires LAPACK for matrices larger than 3x3).
-  #
+  # Make a copy of the matrix, then invert using Gauss-Jordan elimination.
+  # Works without LAPACK.
   #
   #
   # * *Returns* :
   #   - A dense NMatrix.
   #
-  def invert
-    if NMatrix.has_clapack?
-      begin
-        self.cast(:dense, self.dtype).invert! # call CLAPACK version
-      rescue NotImplementedError # probably a rational matrix
-        inverse = self.clone_structure
-        __inverse_exact__(inverse)
+  def invert lda=nil, ldb=nil
+    if lda.nil? and ldb.nil?
+      if NMatrix.has_clapack?
+        begin
+          self.cast(:dense, self.dtype).invert! # call CLAPACK version
+        rescue NotImplementedError # probably a rational matrix
+          inverse = self.clone
+          __inverse__(inverse, false)
+        end
+      elsif self.integer_dtype? # FIXME: This check is probably too slow.
+        rational_self = self.cast(dtype: :rational128)
+        inverse       = rational_self.clone
+        rational_self.__inverse__(inverse, false)
+      else
+        inverse       = self.clone
+        __inverse__(inverse, false)
       end
-    elsif self.integer_dtype? # FIXME: This check is probably too slow.
-      rational_self = self.cast(dtype: :rational128)
-      inverse       = rational_self.clone_structure
-      rational_self.__inverse_exact__(inverse)
     else
-      inverse       = self.clone_structure
-      __inverse_exact__(inverse)
+      inverse = self.clone_structure
+      if self.integer_dtype?
+        __inverse_exact__(inverse.cast(dtype: :rational128), lda, ldb)
+      else
+        dtype = self.dtype
+        __inverse_exact__(inverse, lda, ldb)
+      end
     end
   end
   alias :inverse :invert
@@ -182,7 +199,7 @@ class NMatrix
   #     gesvd! -> [u, sigma, v_transpose]
   #     gesvd! -> [u, sigma, v_conjugate_transpose] # complex
   #
-  # Compute the singular value decomposition of a matrix using LAPACK's GESVD function. 
+  # Compute the singular value decomposition of a matrix using LAPACK's GESVD function.
   # This is destructive, modifying the source NMatrix.  See also #gesdd.
   #
   # Optionally accepts a +workspace_size+ parameter, which will be honored only if it is larger than what LAPACK
@@ -219,7 +236,7 @@ class NMatrix
   # Optionally accepts a +workspace_size+ parameter, which will be honored only if it is larger than what LAPACK
   # requires.
   #
-  def gesdd!(workspace_size=1)
+  def gesdd!(workspace_size=nil)
     NMatrix::LAPACK::gesdd(self, workspace_size)
   end
 
@@ -234,7 +251,7 @@ class NMatrix
   # Optionally accepts a +workspace_size+ parameter, which will be honored only if it is larger than what LAPACK
   # requires.
   #
-  def gesdd(workspace_size=1)
+  def gesdd(workspace_size=nil)
     self.clone.gesdd!(workspace_size)
   end
   #
@@ -360,6 +377,26 @@ class NMatrix
     end
   end
 
+  #
+  # call-seq:
+  #     trace -> Numeric
+  #
+  # Calculates the trace of an nxn matrix.
+  #
+  # * *Raises* :
+  #   - +ShapeError+ -> Expected square matrix
+  #
+  # * *Returns* :
+  #   - The trace of the matrix (a numeric value)
+  #
+  def trace
+    raise(ShapeError, "Expected square matrix") unless self.shape[0] == self.shape[1] && self.dim == 2
+
+    (0...self.shape[0]).inject(0) do |total,i|
+      total + self[i,i]
+    end
+  end
+
   ##
   # call-seq:
   #   mean() -> NMatrix
@@ -518,6 +555,7 @@ class NMatrix
   #
   # Return the sum of the contents of the vector. This is the BLAS asum routine.
   def asum incx=1, n=nil
+    return self[0].abs if self.shape == [1]
     return method_missing(:asum, incx, n) unless vector?
     NMatrix::BLAS::asum(self, incx, self.size / incx)
   end
@@ -569,7 +607,8 @@ protected
 
   # These don't actually take an argument -- they're called reverse-polish style on the matrix.
   # This group always gets casted to float64.
-  [:log, :log2, :log10, :sqrt, :sin, :cos, :tan, :acos, :asin, :atan, :cosh, :sinh, :tanh, :acosh, :asinh, :atanh, :exp, :erf, :erfc, :gamma, :cbrt].each do |ewop|
+  [:log, :log2, :log10, :sqrt, :sin, :cos, :tan, :acos, :asin, :atan, :cosh, :sinh, :tanh, :acosh,
+   :asinh, :atanh, :exp, :erf, :erfc, :gamma, :cbrt].each do |ewop|
     define_method("__list_unary_#{ewop}__") do
       self.__list_map_stored__(nil) { |l| Math.send(ewop, l) }.cast(stype, NMatrix.upcast(dtype, :float64))
     end
@@ -581,7 +620,8 @@ protected
     end
   end
 
-  # log takes an optional single argument, the base.  Default to natural log.
+  #:stopdoc:
+  # log takes an optional single argument, the base. Default to natural log.
   def __list_unary_log__(base)
     self.__list_map_stored__(nil) { |l| Math.log(l, base) }.cast(stype, NMatrix.upcast(dtype, :float64))
   end
@@ -606,6 +646,35 @@ protected
   def __dense_unary_negate__
     self.__dense_map__ { |l| -l }.cast(stype, dtype)
   end
+  #:startdoc:
+
+  # These are for rounding each value of a matrix
+  def __list_unary_round__
+    if self.complex_dtype?
+      self.__list_map_stored__(nil) { |l| Complex(l.real.round, l.imag.round) }
+                                    .cast(stype, dtype)
+    else
+      self.__list_map_stored__(nil) { |l| l.round }.cast(stype, dtype)
+    end
+  end
+
+  def __yale_unary_round__
+    if self.complex_dtype?
+      self.__yale_map_stored__ { |l| Complex(l.real.round, l.imag.round) }
+                                    .cast(stype, dtype)
+    else
+      self.__yale_map_stored__ { |l| l.round }.cast(stype, dtype)
+    end
+  end
+
+  def __dense_unary_round__
+    if self.complex_dtype?
+      self.__dense_map__ { |l| Complex(l.real.round, l.imag.round) }
+                                    .cast(stype, dtype)
+    else
+      self.__dense_map__ { |l| l.round }.cast(stype, dtype)
+    end
+  end
 
   # These are for calculating the floor or ceil of matrix
   def dtype_for_floor_or_ceil
@@ -618,36 +687,36 @@ protected
     return_dtype
   end
 
-  [:floor, :ceil].each do |meth|  
+  [:floor, :ceil].each do |meth|
     define_method("__list_unary_#{meth}__") do
       return_dtype = dtype_for_floor_or_ceil
 
       if [:complex64, :complex128].include?(self.dtype)
-        self.__list_map_stored__(nil) { |l| Complex(l.real.send(meth), l.imag.send(meth)) }.cast(stype, return_dtype) 
+        self.__list_map_stored__(nil) { |l| Complex(l.real.send(meth), l.imag.send(meth)) }.cast(stype, return_dtype)
       else
-        self.__list_map_stored__(nil) { |l| l.send(meth) }.cast(stype, return_dtype)   
+        self.__list_map_stored__(nil) { |l| l.send(meth) }.cast(stype, return_dtype)
       end
     end
-    
-    define_method("__yale_unary_#{meth}__") do 
+
+    define_method("__yale_unary_#{meth}__") do
       return_dtype = dtype_for_floor_or_ceil
 
       if [:complex64, :complex128].include?(self.dtype)
-        self.__yale_map_stored__ { |l| Complex(l.real.send(meth), l.imag.send(meth)) }.cast(stype, return_dtype) 
+        self.__yale_map_stored__ { |l| Complex(l.real.send(meth), l.imag.send(meth)) }.cast(stype, return_dtype)
       else
-        self.__yale_map_stored__ { |l| l.send(meth) }.cast(stype, return_dtype)   
+        self.__yale_map_stored__ { |l| l.send(meth) }.cast(stype, return_dtype)
       end
     end
-    
+
     define_method("__dense_unary_#{meth}__") do
       return_dtype = dtype_for_floor_or_ceil
-       
+
       if [:complex64, :complex128].include?(self.dtype)
-        self.__dense_map__ { |l| Complex(l.real.send(meth), l.imag.send(meth)) }.cast(stype, return_dtype) 
+        self.__dense_map__ { |l| Complex(l.real.send(meth), l.imag.send(meth)) }.cast(stype, return_dtype)
       else
-        self.__dense_map__ { |l| l.send(meth) }.cast(stype, return_dtype)   
+        self.__dense_map__ { |l| l.send(meth) }.cast(stype, return_dtype)
       end
-    end     
+    end
   end
 
   # These take two arguments. One might be a matrix, and one might be a scalar.

data/lib/nmatrix/monkeys.rb

@@ -38,19 +38,55 @@ class Array
   # You must provide a shape for the matrix as the first argument.
   #
   # == Arguments:
-  # <tt>shape</tt> :: Array describing matrix dimensions (or Fixnum for square) -- REQUIRED!
-  # <tt>dtype</tt> :: Override data type (e.g., to store a Float as :float32 instead of :float64) -- optional.
+  # <tt>shape</tt> :: Array describing matrix dimensions (or Fixnum for square). 
+  #   If not provided, will be intuited through #shape.
+  # <tt>dtype</tt> :: Override data type (e.g., to store a Float as :float32 
+  #   instead of :float64) -- optional.
   # <tt>stype</tt> :: Optional storage type (defaults to :dense)
-  def to_nm(shape, dtype = nil, stype = :dense)
-    dtype ||=
-      case self[0]
-      when Fixnum		then :int64
-      when Float		then :float64
-      when Rational	then :rational128
-      when Complex	then :complex128
+  def to_nm(shape = nil, dtype = nil, stype = :dense)
+    elements = self
+
+    guess_dtype = ->(type) {
+      case type
+      when Fixnum   then :int64
+      when Float    then :float64
+      when Rational then :rational128
+      when Complex  then :complex128
+      end
+    }
+
+    guess_shape = lambda { |shapey; shape|
+      # Get the size of the current dimension
+      shape = [shapey.size]
+      shape << shapey.map {|s|
+        if s.respond_to?(:size) && s.respond_to?(:map)
+          guess_shape.call(s)
+        else
+          nil
+        end
+      }
+      if shape.last.any? {|s| (s != shape.last.first) || s.nil?}
+        shape.pop
+      end
+      if (shape.first != shape.last) && shape.last.all? {|s| s == shape.last.first}
+        shape[-1] = shape.last.first
       end
+      shape.flatten
+    }
 
-    matrix = NMatrix.new(:dense, shape, self, dtype)
+    unless shape
+      shape = guess_shape.call(self)
+      elements.flatten!(shape.size - 1)
+      if elements.flatten != elements
+        dtype = :object
+      else
+        dtype ||= guess_dtype[elements[0]]
+      end
+    end
+
+    dtype ||= guess_dtype[self[0]]
+
+    matrix = NMatrix.new(:dense, shape, elements, dtype)
 
     if stype != :dense then matrix.cast(stype, dtype) else matrix end
   end
@@ -64,7 +100,7 @@ class Object #:nodoc:
 end
 
 
-module Math
+module Math #:nodoc:
   class << self
     NMatrix::NMMath::METHODS_ARITY_2.each do |meth|
       define_method "nm_#{meth}" do |arg0, arg1|
@@ -82,3 +118,23 @@ module Math
   end
 end
 
+class String
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end
+
+# Since `autoload` will most likely be deprecated (due to multi-threading concerns),
+# we'll use `const_missing`. See: https://www.ruby-forum.com/topic/3036681 for more info.
+module AutoloadPatch #:nodoc
+  def const_missing(name)
+    file = name.to_s.underscore
+    require "nmatrix/io/#{file}"
+    klass = const_get(name)
+    return klass if klass
+  end
+end