nmatrix 0.0.2 → 0.0.3

data/ext/nmatrix/util/sl_list.cpp

@@ -344,14 +344,14 @@ NODE* find_nearest_from(NODE* prev, size_t key) {
 
   f = find_preceding_from(prev, key);
 
-  if (!f->next) {
+  if (!f->next) { // key exceeds final node; return final node.
   	return f;
   	
-  } else if (key == f->next->key) {
+  } else if (key == f->next->key) { // node already present; return location
   	return f->next;
-  	
+
   } else {
-  	return prev;
+  	return f;
   }
 }
 
@@ -417,7 +417,7 @@ extern "C" {
   /*
    * C access for copying the contents of a list.
    */
-  void nm_list_cast_copy_contents(LIST* lhs, const LIST* rhs, dtype_t lhs_dtype, dtype_t rhs_dtype, size_t recursions) {
+  void nm_list_cast_copy_contents(LIST* lhs, const LIST* rhs, nm::dtype_t lhs_dtype, nm::dtype_t rhs_dtype, size_t recursions) {
     LR_DTYPE_TEMPLATE_TABLE(nm::list::cast_copy_contents, void, LIST*, const LIST*, size_t);
 
     ttable[lhs_dtype][rhs_dtype](lhs, rhs, recursions);
@@ -429,7 +429,7 @@ extern "C" {
    * the default value is going to be a hash with default value of hash with default value of default_value, and so on.
    * In other words, it's recursive.
    */
-  static VALUE empty_list_to_hash(const dtype_t dtype, size_t recursions, VALUE default_value) {
+  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);
@@ -443,7 +443,7 @@ extern "C" {
   /*
    * Copy a list to a Ruby Hash
    */
-  VALUE nm_list_copy_to_hash(const LIST* l, const dtype_t dtype, size_t recursions, VALUE default_value) {
+  VALUE nm_list_copy_to_hash(const LIST* l, const nm::dtype_t dtype, size_t recursions, VALUE default_value) {
 
     // Create a hash with default values appropriately specified for a sparse matrix.
     VALUE h = empty_list_to_hash(dtype, recursions, default_value);

data/ext/nmatrix/util/sl_list.h

@@ -248,8 +248,8 @@ void cast_copy_contents(LIST* lhs, const LIST* rhs, size_t recursions);
 }} // end of namespace nm::list
 
 extern "C" {
-  void nm_list_cast_copy_contents(LIST* lhs, const LIST* rhs, dtype_t lhs_dtype, dtype_t rhs_dtype, size_t recursions);
-  VALUE nm_list_copy_to_hash(const LIST* l, const dtype_t dtype, size_t recursions, VALUE default_value);
+  void nm_list_cast_copy_contents(LIST* lhs, const LIST* rhs, nm::dtype_t lhs_dtype, nm::dtype_t rhs_dtype, size_t recursions);
+  VALUE nm_list_copy_to_hash(const LIST* l, const nm::dtype_t dtype, size_t recursions, VALUE default_value);
 } // end of extern "C" block
 
 #endif // SL_LIST_H

data/lib/nmatrix.rb

@@ -53,3 +53,12 @@ end
 
 # Monkey patches.
 require 'nmatrix/monkeys'
+
+#############
+# Autoloads #
+#############
+
+autoload :NMatrix, 'nmatrix/nmatrix'
+autoload :NVector, 'nmatrix/nvector'
+
+require "nmatrix/shortcuts.rb"

data/lib/nmatrix/blas.rb

@@ -37,8 +37,8 @@ module NMatrix::BLAS
 
     	# NM_COMPLEX64 and NM_COMPLEX128 both require complex alpha and beta.
     	if a.dtype == :complex64 or a.dtype == :complex128
-    		alpha = Complex.new(1.0, 0.0) if alpha == 1.0
-    		beta  = Complex.new(0.0, 0.0) if beta  == 0.0
+    		alpha = Complex(1.0, 0.0) if alpha == 1.0
+    		beta  = Complex(0.0, 0.0) if beta  == 0.0
     	end
 
     	# For argument descriptions, see: http://www.netlib.org/blas/dgemm.f
@@ -57,8 +57,8 @@ module NMatrix::BLAS
 
     	# NM_COMPLEX64 and NM_COMPLEX128 both require complex alpha and beta.
     	if a.dtype == :complex64 or a.dtype == :complex128
-    		alpha = Complex.new(1.0, 0.0) if alpha == 1.0
-    		beta  = Complex.new(0.0, 0.0) if beta  == 0.0
+    		alpha = Complex(1.0, 0.0) if alpha == 1.0
+    		beta  = Complex(0.0, 0.0) if beta  == 0.0
     	end
 
     	::NMatrix::BLAS.cblas_gemv(transpose_a, m, n, alpha, a, lda, x, incx, beta, y, incy)

data/lib/nmatrix/io/market.rb

@@ -0,0 +1,227 @@
+# = 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
+#
+# == io/market.rb
+#
+# MatrixMarket reader and writer.
+#
+module NMatrix::IO::Market
+  CONVERTER_AND_DTYPE = {
+      :real => [:to_f, :float64],
+      :complex => [:to_c, :complex128],
+      :integer => [:to_i, :int64],
+      :pattern => [:to_i, :byte]
+  }
+
+  ENTRY_TYPE = {
+      :byte => :integer, :int8 => :integer, :int16 => :integer, :int32 => :integer, :int64 => :integer,
+      :float32 => :real, :float64 => :real, :complex64 => :complex, :complex128 => :complex
+  }
+
+  class << self
+    # Load a MatrixMarket file. Requires a filename as an argument.
+    def load filename
+
+      f = File.new(filename, "r")
+
+      header = f.gets
+      header.chomp!
+      raise(IOError, "expected type code line beginning with '%%MatrixMarket matrix'") if header !~ /^\%\%MatrixMarket\ matrix/
+
+      header = header.split
+
+      entry_type = header[3].downcase.to_sym
+      symmetry   = header[4].downcase.to_sym
+      converter, default_dtype = CONVERTER_AND_DTYPE[entry_type]
+
+      if header[2] == 'coordinate'
+        load_coordinate f, converter, default_dtype, entry_type, symmetry
+      else
+        load_array f, converter, default_dtype, entry_type, symmetry
+      end
+    end
+
+
+    # Can optionally set :symmetry to :general, :symmetric, :hermitian; and can set :pattern => true if you're writing
+    # a sparse matrix and don't want values stored.
+    def save matrix, filename, options = {}
+      options = {:pattern => false,
+                 :symmetry => :general}.merge(options)
+
+      mode = matrix.stype == :dense ? :array : :coordinate
+      if [:rational32,:rational64,:rational128,:object].include?(matrix.dtype)
+        raise(DataTypeError, "MatrixMarket does not support rational or Ruby objects")
+      end
+      entry_type = options[:pattern] ? :pattern : ENTRY_TYPE[matrix.dtype]
+
+      raise(ArgumentError, "expected two-dimensional NMatrix") if matrix.dim != 2
+
+      f = File.new(filename, 'w')
+
+      f.puts "%%MatrixMarket matrix #{mode} #{entry_type} #{options[:symmetry]}"
+
+      if matrix.stype == :dense
+        save_array matrix, f, options[:symmetry]
+      elsif [:list,:yale].include?(matrix.stype)
+        save_coordinate matrix, f, options[:symmetry], options[:pattern]
+      end
+
+      f.close
+
+      true
+    end
+
+
+  protected
+
+    def save_coordinate matrix, file, symmetry, pattern
+      # Convert to a hash in order to store
+      rows = matrix.to_h
+
+      # Count non-zeros
+      count = 0
+      rows.each_pair do |i, columns|
+        columns.each_pair do |j, val|
+          next if symmetry != :general && j > i
+          count += 1
+        end
+      end
+
+      # Print dimensions and non-zeros
+      file.puts "#{matrix.shape[0]}\t#{matrix.shape[1]}\t#{count}"
+
+      # Print coordinates
+      rows.each_pair do |i, columns|
+        columns.each_pair do |j, val|
+          next if symmetry != :general && j > i
+          file.puts(pattern ? "\t#{i+1}\t#{j+1}" : "\t#{i+1}\t#{j+1}\t#{val}")
+        end
+      end
+
+      file
+    end
+
+
+    def save_array matrix, file, symmetry
+      file.puts [matrix.shape[0], matrix.shape[1]].join("\t")
+
+      if symmetry == :general
+        (0...matrix.shape[1]).each do |j|
+          (0...matrix.shape[0]).each do |i|
+            file.puts matrix[i,j]
+          end
+        end
+      else # :symmetric, :'skew-symmetric', :hermitian
+        (0...matrix.shape[1]).each do |j|
+          (j...matrix.shape[0]).each do |i|
+            file.puts matrix[i,j]
+          end
+        end
+      end
+
+      file
+    end
+
+
+    def load_array file, converter, dtype, entry_type, symmetry
+      mat = nil
+
+      line = file.gets
+      line.chomp!
+      line.lstrip!
+
+      fields = line.split
+
+      mat = NMatrix.new :dense, [fields[0].to_i, fields[1].to_i], dtype
+
+      (0...mat.shape[1]).each do |j|
+        (0...mat.shape[0]).each do |i|
+          datum = file.gets.chomp.send(converter)
+          mat[i,j] = datum
+
+          unless i == j || symmetry == :general
+            if symmetry == :symmetric
+              mat[j,i] = datum
+            elsif symmetry == :hermitian
+              mat[j,i] = Complex.new(datum.real, -datum.imag)
+            elsif symmetry == :'skew-symmetric'
+              mat[j,i] = -datum
+            end
+          end
+        end
+      end
+
+      file.close
+
+      mat
+    end
+
+
+    # Creates a :list NMatrix from a coordinate-list MatrixMarket file.
+    def load_coordinate file, converter, dtype, entry_type, symmetry
+
+      mat = nil
+
+      # Read until we get the dimensions and nonzeros
+      while line = file.gets
+        line.chomp!
+        line.lstrip!
+        line, comment = line.split('%', 2) # ignore comments
+        if line.size > 4
+          shape0, shape1, nz = line.split
+          mat = NMatrix.new(:list, [shape0.to_i, shape1.to_i], 0, dtype)
+          break
+        end
+      end
+
+      # Now read the coordinates
+      while line = file.gets
+        line.chomp!
+        line.lstrip!
+        line, comment = line.split('%', 2) # ignore comments
+
+        next unless line.size >= 5 # ignore empty lines
+
+        fields = line.split
+
+        i = fields[0].to_i - 1
+        j = fields[1].to_i - 1
+        datum = entry_type == :pattern ? 1 : fields[2].send(converter)
+
+        mat[i, j] = datum # add to the matrix
+        unless i == j || symmetry == :general
+          if symmetry == :symmetric
+            mat[j, i] = datum
+          elsif symmetry == :'skew-symmetric'
+            mat[j, i] = -datum
+          elsif symmetry == :hermitian
+            mat[j, i] = Complex.new(datum.real, -datum.imag)
+          end
+        end
+      end
+
+      file.close
+
+      mat
+    end
+  end
+end

data/lib/nmatrix/io/mat_reader.rb

@@ -21,7 +21,7 @@ require "packable"
 #
 # * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
 #
-# == io/matlab/mat_reader.rb
+# == io/mat_reader.rb
 #
 # Base class for .mat file reading (Matlab files).
 #
@@ -42,8 +42,8 @@ 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}],
-			:miDOUBLE	=> [Float,   {:precision	=> :double,	:bytes => 8}],
+			: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}]
 		}
@@ -54,10 +54,10 @@ module NMatrix::IO::Matlab
 			:int16			=> [Integer,	{:signed		=> true,		:bytes => 2}],
 			:int32			=> [Integer,	{:signed		=> true,		:bytes => 4}],
 			:int64			=> [Integer,	{:signed		=> true,		:bytes => 8}],
-			:float32		=> [Float,		{:precision	=> :single,	:bytes => 4}],
-			:float64		=> [Float,		{:precision	=> :double,	:bytes => 8}],
-			:complex64	=> [Float,		{:precision	=> :single,	:bytes => 4}], #2x
-			:complex128	=> [Float,		{:precision	=> :double,	: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 = {

data/lib/nmatrix/lapack.rb

@@ -0,0 +1,80 @@
+# = 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
+#
+# == lapack.rb
+#
+# This file contains LAPACK functions accessible in their C versions,
+# e.g., NMatrix::LAPACK::clapack_func. There are some exceptions,
+# such as clapack_gesv, which is implemented in Ruby but calls
+# clapack_getrf and clapack_getrs.
+#
+# Note: most of these functions are borrowed from ATLAS, which is available under a BSD-
+# style license.
+
+class NMatrix
+  module LAPACK
+    class << self
+
+      # clapack_gesv computes the solution to a system of linear equations
+      #   A * X = B,
+      # where A is an N-by-N matrix and X and B are N-by-NRHS matrices.
+      # The LU factorization used to factor A is dependent on the Order parameter,
+      # as detailed in the leading comments of clapack_getrf.
+      # The factored form of A is then used solve the system of equations A * X = B.
+      # A is overwritten with the appropriate LU factorization, and B, which
+      # contains B on input, is overwritten with the solution X on output.
+      #
+      # From ATLAS 3.8.0.
+      #
+      # Note: Because this function is implemented in Ruby, the ATLAS lib version is
+      # never called! For float32, float64, complex64, and complex128, the ATLAS lib
+      # versions of getrf and getrs *will* be called.
+      def clapack_gesv(order, n, nrhs, a, lda, ipiv, b, ldb)
+        clapack_getrf(order, n, n, a, lda, ipiv)
+        clapack_getrs(order, :no_transpose, n, nrhs, a, lda, ipiv, b, ldb)
+      end
+
+      # clapack_posv computes the solution to a real system of linear equations
+      #   A * X = B,
+      # where A is an N-by-N symmetric positive definite matrix and X and B
+      # are N-by-NRHS matrices.
+      #
+      # The Cholesky decomposition is used to factor A as
+      #   A = U**T* U,  if UPLO = 'U', or
+      #   A = L * L**T,  if UPLO = 'L',
+      # where U is an upper triangular matrix and L is a lower triangular
+      # matrix.  The factored form of A is then used to solve the system of
+      # equations A * X = B.
+      #
+      # From ATLAS 3.8.0.
+      #
+      # Note: Because this function is implemented in Ruby, the ATLAS lib version is
+      # never called! For float32, float64, complex64, and complex128, the ATLAS lib
+      # versions of potrf and potrs *will* be called.
+      def clapack_posv(order, uplo, n, nrhs, a, lda, b, ldb)
+        clapack_potrf(order, uplo, n, a, lda)
+        clapack_potrs(order, uplo, n, nrhs, a, lda, b, ldb)
+      end
+
+    end
+  end
+end

data/lib/nmatrix/nmatrix.rb

@@ -29,6 +29,8 @@
 # Requires #
 ############
 
+require_relative './shortcuts.rb'
+
 #######################
 # Classes and Modules #
 #######################
@@ -47,7 +49,11 @@ class NMatrix
       autoload :MatReader, 'nmatrix/io/mat_reader'
       autoload :Mat5Reader, 'nmatrix/io/mat5_reader'
     end
-	end
+
+    # FIXME: Remove autoloads
+    autoload :Market, 'nmatrix/io/market'
+  end
+
 
 	# TODO: Make this actually pretty.
 	def pretty_print(q = nil)
@@ -80,6 +86,74 @@ class NMatrix
 	end
 	alias :pp :pretty_print
 
+  # These shortcuts use #shape to return the number of rows and columns.
+  def rows
+    shape[0]
+  end
+  
+  def cols
+    shape[1]
+  end
+
+  # 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.
+  def invert!
+    # 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[0], self, self.shape[0], pivot)
+
+    self
+  end
+
+  # Make a copy of the matrix, then invert it (requires LAPACK). Returns a dense matrix.
+  def invert
+    self.cast(:dense, self.dtype).invert!
+  end
+
+  alias :inverse :invert
+
+  # Calls clapack_getrf and returns the pivot array (dense only).
+  def getrf!
+    raise(StorageTypeError, "ATLAS functions only work on dense matrices") unless self.stype == :dense
+    NMatrix::LAPACK::clapack_getrf(:row, self.shape[0], self.shape[1], self, self.shape[0])
+  end
+
+  # Calculate the determinant by way of LU decomposition. This is accomplished using
+  # clapack_getrf, and then by summing the diagonal elements. There is a risk of
+  # underflow/overflow.
+  #
+  # There are probably also more efficient ways to calculate the determinant. This method
+  # requires making a copy of the matrix, since clapack_getrf modifies its input.
+  #
+  # For smaller matrices, you may be able to use det_exact.
+  #
+  # This function is guaranteed to return the same type of data in the matrix upon which it is called.
+  # In other words, if you call it on a rational matrix, you'll get a rational number back.
+  #
+  # Integer matrices are converted to rational matrices for the purposes of performing the calculation,
+  # as xGETRF can't work on integer matrices.
+  def det
+    raise(NotImplementedError, "determinant can be calculated only for 2D matrices") unless self.dim == 2
+
+    # Cast to a dtype for which getrf is implemented
+    new_dtype = [:byte,:int8,:int16,:int32,:int64].include?(self.dtype) ? :rational128 : self.dtype
+    copy = self.cast(:dense, new_dtype)
+
+    # Need to know the number of permutations. We'll add up the diagonals of the factorized matrix.
+    pivot = copy.getrf!
+
+    prod = pivot.size % 2 == 1 ? -1 : 1 # odd permutations => negative
+    [shape[0],shape[1]].min.times do |i|
+      prod *= copy[i,i]
+    end
+
+    # Convert back to an integer if necessary
+    new_dtype != self.dtype ? prod.to_i : prod
+  end
+
 
 	# Get the complex conjugate of this matrix. See also complex_conjugate! for
 	# an in-place operation (provided the dtype is already :complex64 or
@@ -124,57 +198,7 @@ class NMatrix
 		def load_file(file_path)
 			NMatrix::IO::Mat5Reader.new(File.open(file_path, 'rb')).to_ruby
 		end
-		
-		# Helper function for loading a file in the first sparse format given here:
-		#   http://math.nist.gov/MatrixMarket/formats.html
-		#
-		# Override type specifier (e.g., 'real') using :read_with => :to_f (or any other string-to-numeric conversion
-		# function), and with :dtype => :float32 or :dtype => :int8 to force storage in a lesser type.
-		def load_matrix_matrix_coordinate_file(filename, options = {})
-			f = File.new(filename, "r")
-
-			func	= options[:read_with]
-			dtype = options[:dtype]
-			
-			line = f.gets
-			raise IOError, 'Incorrect file type specifier.' unless line =~ /^%%MatrixMarket\ matrix\ coordinate/
-			spec = line.split
-			
-			case spec[3]
-			when 'real'
-				func	||= :to_f
-				dtype ||= :float64
-			when 'integer'
-				func	||= :to_i
-				dtype ||= :int64
-			when 'complex'
-				func	||= :to_complex
-				dtype ||= :complex128
-			when 'rational'
-				func	||= :to_rational
-				dtype ||= :rational128
-			else
-				raise ArgumentError, 'Unrecognized dtype.'
-			end unless func and dtype
-			
-			begin
-				line = f.gets
-			end while line =~ /^%/
-			
-			# Close the file.
-			f.close
-			
-			rows, cols, entries = line.split.collect { |x| x.to_i }
-			
-			matrix = NMatrix.new(:yale, [rows, cols], entries, dtype)
-			
-			entries.times do
-				i, j, v = line.split
-				matrix[i.to_i - 1, j.to_i - 1] = v.send(func)
-			end
-			
-			matrix
-		end
+
 	end
 
 protected
@@ -197,3 +221,5 @@ protected
 		ary
 	end
 end
+
+require_relative "./lapack.rb"