nmatrix 0.1.0.rc1 → 0.1.0.rc2

data/ext/nmatrix/util/sl_list.cpp

@@ -49,6 +49,10 @@ namespace nm { namespace list {
  * Macros
  */
 
+#ifndef RHASH_SET_IFNONE
+#define RHASH_SET_IFNONE(h, v) (RHASH(h)->ifnone = (v))
+#endif
+
 /*
  * Global Variables
  */
@@ -580,9 +584,9 @@ extern "C" {
   static VALUE empty_list_to_hash(const nm::dtype_t dtype, size_t recursions, VALUE default_value) {
     VALUE h = rb_hash_new();
     if (recursions) {
-      RHASH_IFNONE(h) = empty_list_to_hash(dtype, recursions-1, default_value);
+      RHASH_SET_IFNONE(h, empty_list_to_hash(dtype, recursions-1, default_value));
     } else {
-      RHASH_IFNONE(h) = default_value;
+      RHASH_SET_IFNONE(h, default_value);
     }
     return h;
   }

data/lib/nmatrix/io/point_cloud.rb

@@ -0,0 +1,182 @@
+#--
+# = 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 - 2014, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2014, John Woods and the 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
+#
+# == io/point_cloud.rb
+#
+# Point Cloud Library (PCL) PCD file IO functions.
+#
+#++
+
+# Reader for a PCD file, specified here:
+#
+# * http://pointclouds.org/documentation/tutorials/pcd_file_format.php
+#
+# Note that this does not take the width or height parameters into account.
+#
+module NMatrix::IO::PointCloud
+
+  class MetaReader
+    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]
+
+    DTYPE_CONVERT = {:byte => :to_i, :int8 => :to_i, :int16 => :to_i, :int32 => :to_i, :float32 => :to_f, :float64 => :to_f}
+
+    # For UINT, just add 1 to the index.
+    INT_DTYPE_BY_SIZE   = {1 => :int8,    2 => :int16,   4 => :int32,   8 => :int64,  16 => :int64}
+    FLOAT_DTYPE_BY_SIZE = {1 => :float32, 2 => :float32, 4 => :float32, 8 => :float64,16 => :float64}
+
+    class << self
+
+      # Given a type and a number of bytes, figure out an appropriate dtype
+      def dtype_by_type_and_size t, s #:nodoc:
+        if t == :f
+          FLOAT_DTYPE_BY_SIZE[s]
+        elsif t == :u
+          return :byte if s == 1
+          INT_DTYPE_BY_SIZE[s*2]
+        else
+          INT_DTYPE_BY_SIZE[s]
+        end
+      end
+    end
+
+    # call-seq:
+    #     PointCloudReader::MetaReader.new(filename) -> MetaReader
+    #
+    # * *Arguments* :
+    #   - +filename+ -> String giving the name of the file to be loaded.
+    # * *Raises* :
+    #   - +NotImplementedError+ -> only ASCII supported currently
+    #   - +IOError+ -> premature end of file
+    #
+    # Open a file and read the metadata at the top; then read the PCD into an
+    # NMatrix.
+    #
+    # In addition to the fields in the PCD file, there will be at least one
+    # additional attribute, :matrix, storing the data.
+    def initialize filename
+      f = File.new(filename, "r")
+
+      ENTRIES.each.with_index do |entry,i|
+        read_entry(f, entry, ASSIGNS[i], CONVERT[i])
+      end
+
+      raise(NotImplementedError, "only ASCII supported currently") unless self.data.first == :ascii
+
+      @matrix = NMatrix.new(self.shape, dtype: self.dtype)
+
+      # Do we want to use to_i or to_f?
+      convert = DTYPE_CONVERT[self.dtype]
+
+      i = 0
+      while line = f.gets
+        @matrix[i,:*] = line.chomp.split.map { |f| f.send(convert) }
+        i += 1
+      end
+
+      raise(IOError, "premature end of file") if i < self.points[0]
+
+    end
+
+    attr_accessor *ENTRIES
+    attr_reader :matrix
+
+  protected
+    # Read the current entry of the header.
+    def read_entry f, entry, assign=nil, convert=nil #:nodoc:
+      assign ||= (entry.to_s + "=").to_sym
+
+      while line = f.gets
+        next if line =~ /^\s*#/ # ignore comment lines
+        line = line.chomp.split(/\s*#/)[0] # ignore the comments after any data
+
+        # Split, remove the entry name, and convert to the correct type.
+        self.send(assign,
+                  line.split.tap { |t| t.shift }.map do |f|
+                    if convert.nil?
+                      f
+                    elsif convert == :downcase_to_sym
+                      f.downcase.to_sym
+                    else
+                      f.send(convert)
+                    end
+                  end)
+
+        # We don't really want to loop.
+        break
+      end
+
+      self.send(entry)
+    end
+
+
+    # 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:
+      @dtype ||= begin
+        dtypes = self.type.map.with_index do |t,k|
+          MetaReader.dtype_by_type_and_size(t, size[k])
+        end.sort.uniq
+
+        # This could probably save one comparison at most, but we assume that
+        # worst case isn't going to happen very often.
+        while dtypes.size > 1
+          d = NMatrix.upcast(dtypes[0], dtypes[1])
+          dtypes.shift
+          dtypes[0] = d
+        end
+
+        dtypes[0]
+      end
+    end
+
+    # Determine the shape of the matrix.
+    def shape
+      @shape ||= [
+          self.points[0],
+          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

data/lib/nmatrix/math.rb

@@ -33,7 +33,7 @@ class NMatrix
   module NMMath
     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]
+      :asinh, :atanh, :exp, :log2, :log10, :sqrt, :cbrt, :erf, :erfc, :gamma, :-@]
   end
 
   #
@@ -43,7 +43,8 @@ class 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.
+  # 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).
   #
   def invert!
     # Get the pivot array; factor the matrix
@@ -59,13 +60,29 @@ class NMatrix
   # call-seq:
   #     invert -> NMatrix
   #
-  # Make a copy of the matrix, then invert it (requires LAPACK).
+  # Make a copy of the matrix, then invert it (requires LAPACK for matrices larger than 3x3).
+  #
+  #
   #
   # * *Returns* :
   #   - A dense NMatrix.
   #
   def invert
-    self.cast(:dense, self.dtype).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)
+      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)
+    end
   end
   alias :inverse :invert
 
@@ -552,7 +569,7 @@ protected
 
   # These don't actually take an argument -- they're called reverse-polish style on the matrix.
   # This group always gets casted to float64.
-  [: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
@@ -577,6 +594,19 @@ protected
     self.__dense_map__ { |l| Math.log(l, base) }.cast(stype, NMatrix.upcast(dtype, :float64))
   end
 
+  # These are for negating matrix contents using -@
+  def __list_unary_negate__
+    self.__list_map_stored__(nil) { |l| -l }.cast(stype, dtype)
+  end
+
+  def __yale_unary_negate__
+    self.__yale_map_stored__ { |l| -l }.cast(stype, dtype)
+  end
+
+  def __dense_unary_negate__
+    self.__dense_map__ { |l| -l }.cast(stype, dtype)
+  end
+
   # These take two arguments. One might be a matrix, and one might be a scalar.
   # See also monkeys.rb, which contains Math module patches to let the first
   # arg be a scalar

data/lib/nmatrix/nmatrix.rb

@@ -49,24 +49,37 @@ class NMatrix
       autoload :Mat5Reader, 'nmatrix/io/mat5_reader'
     end
 
-    # FIXME: Remove autoloads
-    autoload :Market, 'nmatrix/io/market'
+    autoload :Market, 'nmatrix/io/market.rb'
+    autoload :PointCloud, 'nmatrix/io/point_cloud.rb'
   end
 
   class << self
     #
     # call-seq:
-    #     load_file(path) -> Mat5Reader
+    #     load_matlab_file(path) -> Mat5Reader
     #
     # * *Arguments* :
-    #   - +path+ -> The path to a version 5 .mat file.
+    #   - +file_path+ -> The path to a version 5 .mat file.
     # * *Returns* :
     #   - A Mat5Reader object.
     #
-    def load_file(file_path)
+    def load_matlab_file(file_path)
       NMatrix::IO::Mat5Reader.new(File.open(file_path, 'rb')).to_ruby
     end
 
+    #
+    # call-seq:
+    #     load_pcd_file(path) -> PointCloudReader::MetaReader
+    #
+    # * *Arguments* :
+    #   - +file_path+ -> The path to a PCL PCD file.
+    # * *Returns* :
+    #   - A PointCloudReader::MetaReader object with the matrix stored in its +matrix+ property
+    #
+    def load_pcd_file(file_path)
+      NMatrix::IO::PointCloudReader::MetaReader.new(file_path)
+    end
+
     #
     # Calculate the size of an NMatrix of a given shape.
     def size(shape)
@@ -226,7 +239,7 @@ class NMatrix
 
 
   ##
-  # call-seq: 
+  # call-seq:
   #   integer_dtype?() -> Boolean
   #
   # Checks if dtype is an integer type
@@ -403,15 +416,45 @@ class NMatrix
   # * *Returns* :
   #   - A copy with a different shape.
   #
-  def reshape new_shape
-    t = reshape_clone_structure(new_shape)
-    left_params  = [:*]*new_shape.size
+  def reshape new_shape,*shapes
+    if new_shape.is_a?Fixnum
+      newer_shape =  [new_shape]+shapes
+    else  # new_shape is an Array
+      newer_shape = new_shape
+    end
+    t = reshape_clone_structure(newer_shape)
+    left_params  = [:*]*newer_shape.size
+    puts(left_params)
     right_params = [:*]*self.shape.size
     t[*left_params] = self[*right_params]
     t
   end
 
 
+  #
+  # call-seq:
+  #     reshape!(new_shape) -> NMatrix
+  #     reshape! new_shape  -> NMatrix
+  #
+  # Reshapes the matrix (in-place) to the desired shape. Note that this function does not do a resize; the product of
+  # the new and old shapes' components must be equal.
+  #
+  # * *Arguments* :
+  #   - +new_shape+ -> Array of positive Fixnums.
+  #
+  def reshape! new_shape,*shapes
+    if self.is_ref?
+      raise(ArgumentError, "This operation cannot be performed on reference slices")
+    else
+      if new_shape.is_a?Fixnum
+        shape =  [new_shape]+shapes
+      else  # new_shape is an Array
+        shape = new_shape
+      end
+      self.reshape_bang(shape)
+    end
+  end
+
   #
   # call-seq:
   #     transpose -> NMatrix
@@ -427,7 +470,9 @@ class NMatrix
   #   - A copy of the matrix, but transposed.
   #
   def transpose(permute = nil)
-    if self.dim <= 2 # This will give an error if dim is 1.
+    if self.dim == 1
+      return self.clone
+    elsif self.dim == 2
       new_shape = [self.shape[1], self.shape[0]]
     elsif permute.nil?
       raise(ArgumentError, "need permutation array of size #{self.dim}")
@@ -771,6 +816,21 @@ class NMatrix
   end
 
 
+  #
+  # call-seq:
+  #     clone_structure -> NMatrix
+  #
+  # This function is like clone, but it only copies the structure and the default value.
+  # None of the other values are copied. It takes an optional capacity argument. This is
+  # mostly only useful for dense, where you may not want to initialize; for other types,
+  # you should probably use +zeros_like+.
+  #
+  def clone_structure(capacity = nil)
+    opts = {stype: self.stype, default: self.default_value, dtype: self.dtype}
+    opts = {capacity: capacity}.merge(opts) if self.yale?
+    NMatrix.new(self.shape, opts)
+  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))
@@ -797,22 +857,6 @@ protected
   end
 
 
-  #
-  # call-seq:
-  #     clone_structure -> NMatrix
-  #
-  # This function is like clone, but it only copies the structure and the default value.
-  # None of the other values are copied. It takes an optional capacity argument. This is
-  # mostly only useful for dense, where you may not want to initialize; for other types,
-  # you should probably use +zeros_like+.
-  #
-  def clone_structure(capacity = nil)
-    opts = {stype: self.stype, default: self.default_value, dtype: self.dtype}
-    opts = {capacity: capacity}.merge(opts) if self.yale?
-    NMatrix.new(self.shape, opts)
-  end
-
-
   # Clone the structure as needed for a reshape
   def reshape_clone_structure(new_shape) #:nodoc:
     raise(ArgumentError, "reshape cannot resize; size of new and old matrices must match") unless self.size == new_shape.inject(1) { |p,i| p *= i }

data/lib/nmatrix/shortcuts.rb

@@ -263,6 +263,7 @@ class NMatrix
     alias :diag :diagonal
     alias :diagonals :diagonal
 
+
     #
     # call-seq:
     #     random(shape) -> NMatrix
@@ -270,6 +271,10 @@ class NMatrix
     # Creates a +:dense+ NMatrix with random numbers between 0 and 1 generated
     # by +Random::rand+. The parameter is the dimension of the matrix.
     #
+    # If you use an integer dtype, make sure to specify :scale as a parameter, or you'll
+    # only get a matrix of 0s. You may not currently generate random numbers for
+    # a rational matrix.
+    #
     # * *Arguments* :
     #   - +shape+ -> Array (or integer for square matrix) specifying the dimensions.
     # * *Returns* :
@@ -280,16 +285,28 @@ class NMatrix
     #   NMatrix.random([2, 2]) # => 0.4859439730644226   0.1783195585012436
     #                               0.23193766176700592  0.4503345191478729
     #
+    #   NMatrix.random([2, 2], :dtype => :byte, :scale => 255) # => [ [252, 108] [44, 12] ]
+    #
     def random(shape, opts={})
+      scale = opts.delete(:scale) || 1.0
+
+      raise(NotImplementedError, "does not support rational random number generation") if opts[:dtype].to_s =~ /^rational/
+
       rng = Random.new
 
       random_values = []
 
+
       # Construct the values of the final matrix based on the dimension.
-      NMatrix.size(shape).times { |i| random_values << rng.rand }
+      if opts[:dtype] == :complex64 || opts[:dtype] == :complex128
+        NMatrix.size(shape).times { |i| random_values << Complex(rng.rand(scale), rng.rand(scale)) }
+      else
+        NMatrix.size(shape).times { |i| random_values << rng.rand(scale) }
+      end
 
       NMatrix.new(shape, random_values, {:dtype => :float64, :stype => :dense}.merge(opts))
     end
+    alias :rand :random
 
     #
     # call-seq: