nmatrix 0.0.1 → 0.0.2

data/lib/nmatrix/io/mat_reader.rb

@@ -0,0 +1,162 @@
+require "packable"
+# = 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/matlab/mat_reader.rb
+#
+# Base class for .mat file reading (Matlab files).
+#
+
+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
+		MDTYPE_UNPACK_ARGS = {
+			:miINT8		=> [Integer, {:signed			=> true,		:bytes => 1}],
+			:miUINT8	=> [Integer, {:signed			=> false,		:bytes => 1}],
+			:miINT16	=> [Integer, {:signed			=> true,		:bytes => 2}],
+			: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}],
+			: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}],
+			:float64		=> [Float,		{:precision	=> :double,	:bytes => 8}],
+			:complex64	=> [Float,		{:precision	=> :single,	:bytes => 4}], #2x
+			:complex128	=> [Float,		{:precision	=> :double,	:bytes => 8}]
+		}
+
+    ITYPE_PACK_ARGS = {
+      :uint8			=> [Integer,	{:signed		=> false,		:bytes => 1}],
+     	:uint16			=> [Integer,	{:signed		=> false,		:bytes => 2}],
+     	:uint32			=> [Integer,	{:signed		=> false,		:bytes => 4}],
+     	:uint64			=> [Integer,	{:signed		=> false,		:bytes => 8}],
+    }
+
+		NO_REPACK = [:miINT8, :miUINT8, :miINT16, :miINT32, :miSINGLE, :miDOUBLE, :miINT64]
+
+		# Convert from MATLAB dtype to NMatrix dtype.
+		MDTYPE_TO_DTYPE = {
+			:miUINT8	=> :byte,
+			:miINT8		=> :int8,
+			:miINT16	=> :int16,
+			:miUINT16	=> :int16,
+			:miINT32	=> :int32,
+			:miUINT32	=> :int32,
+			:miINT64	=> :int64,
+			:miUINT64	=> :int64,
+			:miSINGLE	=> :float32,
+			:miDOUBLE	=> :float64
+		}
+
+    MDTYPE_TO_ITYPE = {
+      :miUINT8 => :uint8,
+      :miINT8 => :uint8,
+      :miINT16	=> :uint16,
+      :miUINT16	=> :uint16,
+      :miINT32	=> :uint32,
+      :miUINT32	=> :uint32,
+      :miINT64	=> :uint64,
+      :miUINT64	=> :uint64
+    }
+
+		# Before release v7.1 (release 14) matlab (TM) used the system
+		# default character encoding scheme padded out to 16-bits. Release 14
+		# and later use Unicode. When saving character data, R14 checks if it
+		# can be encoded in 7-bit ascii, and saves in that format if so.
+		MDTYPES = [
+			nil,
+			:miINT8,
+			:miUINT8,
+			:miINT16,
+			:miUINT16,
+			:miINT32,
+			:miUINT32,
+			:miSINGLE,
+			nil,
+			:miDOUBLE,
+			nil,
+			nil,
+			:miINT64,
+			:miUINT64,
+			:miMATRIX,
+			:miCOMPRESSED,
+			:miUTF8,
+			:miUTF16,
+			:miUTF32
+		]
+		
+		MCLASSES = [
+			nil,
+			:mxCELL,
+			:mxSTRUCT,
+			:mxOBJECT,
+			:mxCHAR,
+			:mxSPARSE,
+			:mxDOUBLE,
+			:mxSINGLE,
+			:mxINT8,
+			:mxUINT8,
+			:mxINT16,
+			:mxUINT16,
+			:mxINT32,
+			:mxUINT32,
+			:mxINT64,
+			:mxUINT64,
+			:mxFUNCTION,
+			:mxOPAQUE,
+			:mxOBJECT_CLASS_FROM_MATRIX_H
+		]
+
+		attr_reader :byte_order
+
+		def initialize(stream, options = {})
+			raise ArgumentError, 'First arg must be IO.' unless stream.is_a?(::IO)
+
+			@stream     = stream
+			@byte_order = options[:byte_order] || guess_byte_order
+		end
+
+		def guess_byte_order
+			# Assume native, since we don't know what type of file we have.
+			:native
+		end
+
+		protected
+		attr_reader :stream
+	end
+end

data/lib/{string.rb → nmatrix/monkeys.rb}

@@ -20,10 +20,57 @@
 #
 # * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
 #
-# == string.rb
+# == monkeys.rb
 #
 # Ruby core extensions for NMatrix.
 
+#######################
+# Classes and Modules #
+#######################
+
+class Array
+	# Convert a Ruby Array to an NMatrix.
+	#
+	# 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>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
+		end
+	
+		matrix = NMatrix.new(:dense, shape, self, dtype)
+	
+		if stype != :dense then matrix.cast(stype, dtype) else matrix end
+	end
+
+  unless method_defined?(:max)
+    def max
+      self.inject(self.first) { |m, n| if n > m then n else m end }
+    end
+  end
+
+  unless method_defined?(:min)
+    def min
+      self.inject(self.first) { |m, n| if n < m then n else m end }
+    end
+  end
+end
+
+class Object
+	def returning(value)
+		yield(value)
+		value
+	end
+end
+
 class String #:nodoc:
   unless method_defined?(:constantize)
     # Based on constantize from ActiveSupport::Inflector
@@ -62,4 +109,4 @@ class String #:nodoc:
       word
     end
   end
-end
+end

data/lib/nmatrix/nmatrix.rb

@@ -0,0 +1,199 @@
+# = 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
+#
+# == nmatrix.rb
+#
+# This file adds a few additional pieces of functionality (e.g., inspect,
+# pretty_print).
+
+############
+# Requires #
+############
+
+#######################
+# Classes and Modules #
+#######################
+
+class NMatrix
+	# Read and write extensions for NMatrix. These are only loaded when needed.
+	module IO
+    module Matlab
+      class << self
+        def load_mat file_path
+          NMatrix::IO::Matlab::Mat5Reader.new(File.open(file_path, "rb+")).to_ruby
+        end
+      end
+
+      # FIXME: Remove autoloads
+      autoload :MatReader, 'nmatrix/io/mat_reader'
+      autoload :Mat5Reader, 'nmatrix/io/mat5_reader'
+    end
+	end
+
+	# TODO: Make this actually pretty.
+	def pretty_print(q = nil)
+		if dim != 2 || (dim == 2 && shape[1] > 10) # FIXME: Come up with a better way of restricting the display
+      inspect
+    else
+
+      arr = (0...shape[0]).map do |i|
+        ary = []
+        (0...shape[1]).each do |j|
+          o = begin
+            self[i, j]
+          rescue ArgumentError
+            nil
+          end
+          ary << (o.nil? ? 'nil' : o)
+        end
+        ary.inspect
+      end
+
+      if q.nil?
+        puts arr.join("\n")
+      else
+        q.group(1, "", "\n") do
+          q.seplist(arr, lambda { q.text "  " }, :each)  { |v| q.text v.to_s }
+        end
+      end
+
+    end
+	end
+	alias :pp :pretty_print
+
+
+	# Get the complex conjugate of this matrix. See also complex_conjugate! for
+	# an in-place operation (provided the dtype is already :complex64 or
+	# :complex128).
+	#
+	# Does not work on list matrices, but you can optionally pass in the type you
+	# want to cast to if you're dealing with a list matrix.
+	def complex_conjugate(new_stype = self.stype)
+		self.cast(new_stype, NMatrix::upcast(dtype, :complex64)).complex_conjugate!
+	end
+
+	# Calculate the conjugate transpose of a matrix. If your dtype is already
+	# complex, this should only require one copy (for the transpose).
+	def conjugate_transpose
+		self.transpose.complex_conjugate!
+	end
+
+	def hermitian?
+		return false if self.dim != 2 or self.shape[0] != self.shape[1]
+		
+		if [:complex64, :complex128].include?(self.dtype)
+			# TODO: Write much faster Hermitian test in C
+			self.eql?(self.conjugate_transpose)
+		else
+			symmetric?
+		end
+	end
+
+	def inspect
+		original_inspect = super()
+		original_inspect = original_inspect[0...original_inspect.size-1]
+		original_inspect + inspect_helper.join(" ") + ">"
+	end
+
+	def __yale_ary__to_s(sym)
+		ary = self.send("__yale_#{sym.to_s}__".to_sym)
+		
+		'[' + ary.collect { |a| a ? a : 'nil'}.join(',') + ']'
+	end
+
+	class << self
+		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
+	def inspect_helper
+		ary = []
+		ary << "shape:[#{shape.join(',')}]" << "dtype:#{dtype}" << "stype:#{stype}"
+
+		if stype == :yale
+			ary <<	"capacity:#{capacity}"
+
+      # These are enabled by the DEBUG_YALE compiler flag in extconf.rb.
+      if respond_to?(:__yale_a__)
+        ary << "ija:#{__yale_ary__to_s(:ija)}" << "ia:#{__yale_ary__to_s(:ia)}" <<
+				  			"ja:#{__yale_ary__to_s(:ja)}" << "a:#{__yale_ary__to_s(:a)}" << "d:#{__yale_ary__to_s(:d)}" <<
+					  		"lu:#{__yale_ary__to_s(:lu)}" << "yale_size:#{__yale_size__}"
+      end
+
+		end
+
+		ary
+	end
+end

data/lib/nmatrix/nvector.rb

@@ -0,0 +1,103 @@
+# = 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
+#
+# == nmatrix.rb
+#
+# This file defines the NVector class.
+
+############
+# Requires #
+############
+
+
+#######################
+# Classes and Modules #
+#######################
+
+# This is a specific type of NMatrix in which only one dimension is not 1.
+# Although it is stored as a dim-2, n x 1, matrix, it acts as a dim-1 vector
+# of size n. If the @orientation flag is set to :row, it is stored as 1 x n
+# instead of n x 1.
+class NVector < NMatrix
+	def initialize(length, *args)
+		super(:dense, [length, 1], *args)
+    orientation
+  end
+
+	# Orientation defaults to column (e.g., [3,1] is a column of length 3). It
+	# may also be row, e.g., for [1,5].
+	def orientation
+		@orientation ||= :column
+	end
+
+	def transpose
+		t = super()
+    t.flip!
+	end
+
+	def transpose!
+		super()
+		self.flip!
+	end
+
+	def multiply(m)
+		t = super(m)
+    t.flip!
+	end
+
+	def multiply!(m)
+		super().flip!
+	end
+
+	def [](i)
+		case @orientation
+		when :column;	super(i, 0)
+		when :row;	  super(0, i)
+		end
+  end
+
+	def []=(i, val)
+		case @orientation
+		when :column;	super(i, 0, val)
+		when :row;	  super(0, i, val)
+		end
+	end
+
+	def dim; 1; end
+
+	# TODO: Make this actually pretty.
+	def pretty_print
+		dim = @orientation == :row ? 1 : 0
+		
+		puts (0...shape[dim]).inject(Array.new) { |a, i| a << self[i] }.join('  ')
+	end
+
+protected
+	def inspect_helper
+		super() << "orientation:#{self.orientation}"
+	end
+	
+	def flip_orientation!
+		returning(self) { @orientation = @orientation == :row ? :column : :row }
+	end
+	alias :flip! :flip_orientation!
+end

data/lib/nmatrix/version.rb

@@ -0,0 +1,27 @@
+# = 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
+#
+
+class NMatrix
+  VERSION = '0.0.2'
+end
+