nmatrix 0.2.1 → 0.2.3

data/lib/nmatrix/io/mat_reader.rb

@@ -9,8 +9,8 @@
 #
 # == Copyright Information
 #
-# SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
-# NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+# SciRuby is Copyright (c) 2010 - 2016, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2016, John Woods and the Ruby Science Foundation
 #
 # Please see LICENSE.txt for additional copyright notices.
 #
@@ -43,22 +43,33 @@ module NMatrix::IO::Matlab
       :miUINT16 => [Integer, {:signed    => false,   :bytes => 2}],
       :miINT32  => [Integer, {:signed    => true,    :bytes => 4}],
       :miUINT32 => [Integer, {:signed    => false,   :bytes => 4}],
-      :miSINGLE => [Float,   {:precision => :single, :bytes => 4, :endian => :native}],
-      :miDOUBLE => [Float,   {:precision => :double, :bytes => 4, :endian => :native}],
+      :miSINGLE => [Float,   {:precision => :single,
+                              :bytes => 4, :endian => :native}],
+      :miDOUBLE => [Float,   {:precision => :double,
+                              :bytes => 4, :endian => :native}],
       :miINT64  => [Integer, {:signed    => true,    :bytes => 8}],
       :miUINT64 => [Integer, {:signed    => false,   :bytes => 8}]
     }
 
     DTYPE_PACK_ARGS = {
-      :byte       => [Integer, {:signed => false,      :bytes => 1}],
-      :int8       => [Integer, {:signed => true,       :bytes => 1}],
-      :int16      => [Integer, {:signed => true,       :bytes => 2}],
-      :int32      => [Integer, {:signed => true,       :bytes => 4}],
-      :int64      => [Integer, {:signed => true,       :bytes => 8}],
-      :float32    => [Float,   {:precision => :single, :bytes => 4, :endian => :native}],
-      :float64    => [Float,   {:precision => :double, :bytes => 8, :endian => :native}],
-      :complex64  => [Float,   {:precision => :single, :bytes => 4, :endian => :native}], #2x
-      :complex128 => [Float,   {:precision => :double, :bytes => 8, :endian => :native}]
+      :byte       => [Integer, {:signed => false,
+                                :bytes => 1}],
+      :int8       => [Integer, {:signed => true,
+                                :bytes => 1}],
+      :int16      => [Integer, {:signed => true,
+                                :bytes => 2}],
+      :int32      => [Integer, {:signed => true,
+                                :bytes => 4}],
+      :int64      => [Integer, {:signed => true,
+                                :bytes => 8}],
+      :float32    => [Float,   {:precision => :single,
+                                :bytes => 4, :endian => :native}],
+      :float64    => [Float,   {:precision => :double,
+                                :bytes => 8, :endian => :native}],
+      :complex64  => [Float,   {:precision => :single,
+                                :bytes => 4, :endian => :native}], #2x
+      :complex128 => [Float,   {:precision => :double,
+                                :bytes => 8, :endian => :native}]
     }
 
     ITYPE_PACK_ARGS = {
@@ -68,7 +79,8 @@ module NMatrix::IO::Matlab
       :uint64 => [Integer, {:signed => false, :bytes => 8}],
     }
 
-    NO_REPACK = [:miINT8, :miUINT8, :miINT16, :miINT32, :miSINGLE, :miDOUBLE, :miINT64]
+    NO_REPACK = [:miINT8, :miUINT8, :miINT16,
+                 :miINT32, :miSINGLE, :miDOUBLE, :miINT64]
 
     # Convert from MATLAB dtype to NMatrix dtype.
     MDTYPE_TO_DTYPE = {

data/lib/nmatrix/io/point_cloud.rb

@@ -9,8 +9,8 @@
 #
 # == Copyright Information
 #
-# SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
-# NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+# SciRuby is Copyright (c) 2010 - 2016, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2016, John Woods and the Ruby Science Foundation
 #
 # Please see LICENSE.txt for additional copyright notices.
 #
@@ -55,15 +55,21 @@ module NMatrix::IO::PointCloud
   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]
+    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}
+    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}
+    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
 
@@ -101,7 +107,8 @@ module NMatrix::IO::PointCloud
         read_entry(f, entry, ASSIGNS[i], CONVERT[i])
       end
 
-      raise(NotImplementedError, "only ASCII supported currently") unless self.data.first == :ascii
+      raise(NotImplementedError, "only ASCII supported currently") \
+       unless self.data.first == :ascii
 
       @matrix = NMatrix.new(self.shape, dtype: self.dtype)
 
@@ -150,8 +157,9 @@ module NMatrix::IO::PointCloud
     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.
+    # 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
       @dtype ||= begin
         dtypes = self.type.map.with_index do |t,k|

data/lib/nmatrix/math.rb

@@ -112,6 +112,55 @@ class NMatrix
   end
   alias :inverse :invert
 
+  #
+  # call-seq:
+  #     adjugate! -> NMatrix
+  #
+  # Calculate the adjugate of the matrix (in-place). 
+  # Only works on dense matrices. 
+  #
+  # * *Raises* :
+  #   - +StorageTypeError+ -> only implemented on dense matrices.
+  #   - +ShapeError+ -> matrix must be square.
+  #   - +DataTypeError+ -> cannot calculate adjugate of an integer matrix in-place.
+  #
+  def adjugate!
+    raise(StorageTypeError, "adjugate only works on dense matrices currently") unless self.dense?
+    raise(ShapeError, "Cannot calculate adjugate of a non-square matrix") unless self.dim == 2 && self.shape[0] == self.shape[1]
+    raise(DataTypeError, "Cannot calculate adjugate of an integer matrix in-place") if self.integer_dtype?
+    d = self.det
+    self.invert!
+    self.map! { |e| e * d } 
+    self
+  end
+  alias :adjoint! :adjugate!
+
+  #
+  # call-seq:
+  #     adjugate -> NMatrix
+  #
+  # Make a copy of the matrix and calculate the adjugate of the matrix. 
+  # Only works on dense matrices. 
+  #
+  # * *Returns* :
+  #   - A dense NMatrix. Will be the same type as the input NMatrix,
+  #   except if the input is an integral dtype, in which case it will be a
+  #   :float64 NMatrix. 
+  #
+  # * *Raises* :
+  #   - +StorageTypeError+ -> only implemented on dense matrices.
+  #   - +ShapeError+ -> matrix must be square.
+  #
+  def adjugate
+    raise(StorageTypeError, "adjugate only works on dense matrices currently") unless self.dense?
+    raise(ShapeError, "Cannot calculate adjugate of a non-square matrix") unless self.dim == 2 && self.shape[0] == self.shape[1]
+    d = self.det
+    mat = self.invert
+    mat.map! { |e| e * d }    
+    mat 
+  end
+  alias :adjoint :adjugate
+
   #
   # call-seq:
   #     getrf! -> Array
@@ -153,6 +202,104 @@ class NMatrix
     return ipiv
   end
 
+  #
+  # call-seq:
+  #     geqrf! -> shape.min x 1 NMatrix 
+  #
+  # QR factorization of a general M-by-N matrix +A+. 
+  #
+  # The QR factorization is A = QR, where Q is orthogonal and R is Upper Triangular
+  # +A+ is overwritten with the elements of R and Q with Q being represented by the 
+  # elements below A's diagonal and an array of scalar factors in the output NMatrix. 
+  #
+  # The matrix Q is represented as a product of elementary reflectors
+  #     Q = H(1) H(2) . . . H(k), where k = min(m,n).
+  #
+  # Each H(i) has the form
+  #
+  #     H(i) = I - tau * v * v'
+  #
+  # http://www.netlib.org/lapack/explore-html/d3/d69/dgeqrf_8f.html
+  # 
+  # Only works for dense matrices.
+  #
+  # * *Returns* :
+  #   - Vector TAU. Q and R are stored in A. Q is represented by TAU and A
+  # * *Raises* :
+  #   - +StorageTypeError+ -> LAPACK functions only work on dense matrices.
+  #
+  def geqrf!
+    # The real implementation is in lib/nmatrix/lapacke.rb
+    raise(NotImplementedError, "geqrf! requires the nmatrix-lapacke gem")
+  end
+  
+  #
+  # call-seq:
+  #     ormqr(tau) -> NMatrix
+  #     ormqr(tau, side, transpose, c) -> NMatrix
+  #
+  # Returns the product Q * c or c * Q after a call to geqrf! used in QR factorization. 
+  # +c+ is overwritten with the elements of the result NMatrix if supplied. Q is the orthogonal matrix 
+  # represented by tau and the calling NMatrix
+  # 
+  # Only works on float types, use unmqr for complex types.
+  #
+  # == Arguments
+  #
+  # * +tau+ - vector containing scalar factors of elementary reflectors
+  # * +side+ - direction of multiplication [:left, :right]
+  # * +transpose+ - apply Q with or without transpose [false, :transpose] 
+  # * +c+ - NMatrix multplication argument that is overwritten, no argument assumes c = identity
+  #
+  # * *Returns* :
+  #
+  #   - Q * c or c * Q Where Q may be transposed before multiplication. 
+  #    
+  #
+  # * *Raises* :
+  #   - +StorageTypeError+ -> LAPACK functions only work on dense matrices.
+  #   - +TypeError+ -> Works only on floating point matrices, use unmqr for complex types
+  #   - +TypeError+ -> c must have the same dtype as the calling NMatrix
+  #
+  def ormqr(tau, side=:left, transpose=false, c=nil)
+    # The real implementation is in lib/nmatrix/lapacke.rb
+    raise(NotImplementedError, "ormqr requires the nmatrix-lapacke gem")
+  
+  end
+
+  #
+  # call-seq:
+  #     unmqr(tau) -> NMatrix
+  #     unmqr(tau, side, transpose, c) -> NMatrix
+  #
+  # Returns the product Q * c or c * Q after a call to geqrf! used in QR factorization. 
+  # +c+ is overwritten with the elements of the result NMatrix if it is supplied. Q is the orthogonal matrix 
+  # represented by tau and the calling NMatrix
+  # 
+  # Only works on complex types, use ormqr for float types.
+  #
+  # == Arguments
+  #
+  # * +tau+ - vector containing scalar factors of elementary reflectors
+  # * +side+ - direction of multiplication [:left, :right]
+  # * +transpose+ - apply Q as Q or its complex conjugate [false, :complex_conjugate] 
+  # * +c+ - NMatrix multplication argument that is overwritten, no argument assumes c = identity
+  #
+  # * *Returns* :
+  #
+  #   - Q * c or c * Q Where Q may be transformed to its complex conjugate before multiplication. 
+  #    
+  #
+  # * *Raises* :
+  #   - +StorageTypeError+ -> LAPACK functions only work on dense matrices.
+  #   - +TypeError+ -> Works only on floating point matrices, use unmqr for complex types
+  #   - +TypeError+ -> c must have the same dtype as the calling NMatrix
+  #
+  def unmqr(tau, side=:left, transpose=false, c=nil)
+    # The real implementation is in lib/nmatrix/lapacke.rb
+    raise(NotImplementedError, "unmqr requires the nmatrix-lapacke gem")
+  end
+
   #
   # call-seq:
   #     potrf!(upper_or_lower) -> NMatrix
@@ -232,6 +379,46 @@ class NMatrix
     [t, FactorizeLUMethods.permutation_matrix_from(pivot)]
   end
 
+  #
+  # call-seq:
+  #     factorize_qr -> [Q,R]
+  #
+  # QR factorization of a matrix without column pivoting. 
+  # Q is orthogonal and R is upper triangular if input is square or upper trapezoidal if 
+  # input is rectangular.  
+  #
+  # Only works for dense matrices.
+  #
+  # * *Returns* :
+  #   - Array containing Q and R matrices
+  #
+  # * *Raises* :
+  #   - +StorageTypeError+ -> only implemented for desnse storage.
+  #   - +ShapeError+ -> Input must be a 2-dimensional matrix to have a QR decomposition.
+  #
+  def factorize_qr
+    raise(NotImplementedError, "only implemented for dense storage") unless self.stype == :dense
+    raise(ShapeError, "Input must be a 2-dimensional matrix to have a QR decomposition") unless self.dim == 2
+
+    rows, columns = self.shape
+    r = self.clone
+    tau =  r.geqrf!
+    
+    #Obtain Q 
+    q = self.complex_dtype? ? r.unmqr(tau) : r.ormqr(tau)
+    
+    #Obtain R    
+    if rows <= columns
+      r.upper_triangle!
+    #Need to account for upper trapezoidal structure if R is a tall rectangle (rows > columns)
+    else
+      r[0...columns, 0...columns].upper_triangle!
+      r[columns...rows, 0...columns] = 0
+    end
+
+    [q,r]
+  end
+
   # Reduce self to upper hessenberg form using householder transforms.
   # 
   # == References
@@ -333,10 +520,8 @@ class NMatrix
     when :lower_tri, :lower_triangular
       raise(ArgumentError, "lower triangular solver does not work with complex dtypes") if
         complex_dtype? or b.complex_dtype?
-      # this is a workaround; see https://github.com/SciRuby/nmatrix/issues/422
-      x = x.transpose
-      NMatrix::BLAS::cblas_trsm(:row, :right, :lower, :transpose, :nounit, nrhs, n, 1.0, self, n, x, n)
-      x.transpose
+      NMatrix::BLAS::cblas_trsm(:row, :left, :lower, false, :nounit, n, nrhs, 1.0, self, n, x, nrhs)
+      x
     when :pos_def, :positive_definite
       u, l = self.factorize_cholesky
       z = l.solve(b, form: :lower_tri)
@@ -848,7 +1033,6 @@ class NMatrix
     end.cast(self.stype, abs_dtype)
   end
 
-
   #
   # call-seq:
   #     absolute_sum -> Numeric
@@ -883,6 +1067,41 @@ class NMatrix
   end
   alias :norm2 :nrm2
 
+  #
+  # call-seq:
+  #     scale! -> NMatrix
+  #
+  # == Arguments
+  #   - +alpha+ -> Scalar value used in the operation.
+  #   - +inc+ -> Increment used in the scaling function. Should generally be 1.
+  #   - +n+ -> Number of elements of +vector+.
+  #
+  # This is a destructive method, modifying the source NMatrix.  See also #scale.
+  # Return the scaling result of the matrix. BLAS scal will be invoked if provided.
+
+  def scale!(alpha, incx=1, n=nil)
+    raise(DataTypeError, "Incompatible data type for the scaling factor") unless
+        NMatrix::upcast(self.dtype, NMatrix::min_dtype(alpha)) == self.dtype
+    return NMatrix::BLAS::scal(alpha, self, incx, self.size / incx) if NMatrix::BLAS.method_defined? :scal
+    self.each_stored_with_indices do |e, *i|
+      self[*i] = e*alpha
+    end
+  end
+
+  #
+  # call-seq:
+  #     scale -> NMatrix
+  #
+  # == Arguments
+  #   - +alpha+ -> Scalar value used in the operation.
+  #   - +inc+ -> Increment used in the scaling function. Should generally be 1.
+  #   - +n+ -> Number of elements of +vector+.
+  #
+  # Return the scaling result of the matrix. BLAS scal will be invoked if provided.
+  
+  def scale(alpha, incx=1, n=nil)
+    return self.clone.scale!(alpha, incx, n)
+  end
 
   alias :permute_columns  :laswp
   alias :permute_columns! :laswp!

data/lib/nmatrix/mkmf.rb

@@ -0,0 +1,103 @@
+require "mkmf"
+
+if RUBY_VERSION < '1.9'
+  raise NotImplementedError, "Sorry, you need at least Ruby 1.9!"
+end
+
+# Function derived from NArray's extconf.rb.
+def create_conf_h(file) #:nodoc:
+  print "creating #{file}\n"
+  File.open(file, 'w') do |hfile|
+    header_guard = file.upcase.sub(/\s|\./, '_')
+
+    hfile.puts "#ifndef #{header_guard}"
+    hfile.puts "#define #{header_guard}"
+    hfile.puts
+
+    # FIXME: Find a better way to do this:
+    hfile.puts "#define RUBY_2 1" if RUBY_VERSION >= '2.0'
+
+    for line in $defs
+      line =~ /^-D(.*)/
+      hfile.printf "#define %s 1\n", $1
+    end
+
+    hfile.puts
+    hfile.puts "#endif"
+  end
+end
+
+def find_newer_gplusplus #:nodoc:
+  print "checking for apparent GNU g++ binary with C++0x/C++11 support... "
+  [9,8,7,6,5,4,3].each do |minor|
+    ver = "4.#{minor}"
+    gpp = "g++-#{ver}"
+    result = `which #{gpp}`
+    next if result.empty?
+    CONFIG['CXX'] = gpp
+    puts ver
+    return CONFIG['CXX']
+  end
+  false
+end
+
+def gplusplus_version
+  cxxvar = proc { |n| `#{CONFIG['CXX']} -E -dM - <#{File::NULL} | grep #{n}`.chomp.split(' ')[2] }
+  major = cxxvar.call('__GNUC__')
+  minor = cxxvar.call('__GNUC_MINOR__')
+  patch = cxxvar.call('__GNUC_PATCHLEVEL__')
+
+  raise("unable to determine g++ version (match to get version was nil)") if major.nil? || minor.nil? || patch.nil?
+
+  "#{major}.#{minor}.#{patch}"
+end
+
+
+if /cygwin|mingw/ =~ RUBY_PLATFORM
+  CONFIG["DLDFLAGS"] << " --output-lib libnmatrix.a"
+end
+
+# Fix compiler pairing
+if CONFIG['CC'] == 'clang' && CONFIG['CXX'] != 'clang++'
+  puts "WARNING: CONFIG['CXX'] is not 'clang++' even though CONFIG['CC'] is 'clang'.",
+       "WARNING: Force to use clang++ together with clang."
+
+  CONFIG['CXX'] = 'clang++'
+end
+
+if CONFIG['CXX'] == 'clang++'
+  $CXX_STANDARD = 'c++11'
+else
+  version = gplusplus_version
+  if version < '4.3.0' && CONFIG['CXX'] == 'g++'  # see if we can find a newer G++, unless it's been overridden by user
+    if !find_newer_gplusplus
+      raise("You need a version of g++ which supports -std=c++0x or -std=c++11. If you're on a Mac and using Homebrew, we recommend using mac-brew-gcc.sh to install a more recent g++.")
+    end
+    version = gplusplus_version
+  end
+
+  if version < '4.7.0'
+    $CXX_STANDARD = 'c++0x'
+  else
+    $CXX_STANDARD = 'c++11'
+  end
+  puts "using C++ standard... #{$CXX_STANDARD}"
+  puts "g++ reports version... " + `#{CONFIG['CXX']} --version|head -n 1|cut -f 3 -d " "`
+end
+
+# For release, these next two should both be changed to -O3.
+$CFLAGS += " -O3 "
+#$CFLAGS += " -static -O0 -g "
+$CXXFLAGS += " -O3 -std=#{$CXX_STANDARD} " #-fmax-errors=10 -save-temps
+#$CXXFLAGS += " -static -O0 -g -std=#{$CXX_STANDARD} "
+
+CONFIG['warnflags'].gsub!('-Wshorten-64-to-32', '') # doesn't work except in Mac-patched gcc (4.2)
+CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
+CONFIG['warnflags'].gsub!('-Wimplicit-function-declaration', '')
+
+have_func("rb_array_const_ptr", "ruby.h")
+have_macro("FIX_CONST_VALUE_PTR", "ruby.h")
+have_macro("RARRAY_CONST_PTR", "ruby.h")
+have_macro("RARRAY_AREF", "ruby.h")
+
+