nmatrix 0.0.3 → 0.0.4

data/lib/nmatrix/io/mat_reader.rb

@@ -1,4 +1,4 @@
-require "packable"
+#--
 # = NMatrix
 #
 # A linear algebra library for scientific computation in Ruby.
@@ -25,63 +25,65 @@ require "packable"
 #
 # 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, :endian => :native}],
-			:miDOUBLE	=> [Float,   {:precision  => :double, :bytes => 4, :endian => :native}],
-			:miINT64	=> [Integer, {:signed			=> true,		:bytes => 8}],
-			:miUINT64	=> [Integer, {:signed			=> false,		:bytes => 8}]
-		}
+  #
+  # 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, :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}]
-		}
+    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}]
+    }
 
     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}],
+      :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]
+    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
-		}
+    # 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,
@@ -94,69 +96,81 @@ module NMatrix::IO::Matlab
       :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
-		]
+    # 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
 
-		attr_reader :byte_order
+    #
+    # call-seq:
+    #     new(stream, options = {}) -> MatReader
+    #
+    # * *Raises* :
+    #   - +ArgumentError+ -> First argument must be IO.
+    #
+    def initialize(stream, options = {})
+      raise ArgumentError, 'First arg must be IO.' unless stream.is_a?(::IO)
 
-		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
 
-			@stream     = stream
-			@byte_order = options[:byte_order] || guess_byte_order
-		end
+    #
+    # call-seq:
+    #     guess_byte_order -> Symbol
+    #
+    def guess_byte_order
+      # Assume native, since we don't know what type of file we have.
+      :native
+    end
 
-		def guess_byte_order
-			# Assume native, since we don't know what type of file we have.
-			:native
-		end
+    protected
 
-		protected
-		attr_reader :stream
-	end
+    attr_reader :stream
+  end
 end

data/lib/nmatrix/lapack.rb

@@ -1,3 +1,4 @@
+#--
 # = NMatrix
 #
 # A linear algebra library for scientific computation in Ruby.
@@ -8,8 +9,8 @@
 #
 # == Copyright Information
 #
-# SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
-# NMatrix is Copyright (c) 2012, Ruby Science Foundation
+# SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
+# NMatrix is Copyright (c) 2013, Ruby Science Foundation
 #
 # Please see LICENSE.txt for additional copyright notices.
 #
@@ -29,31 +30,60 @@
 #
 # 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
+      #
+      # call-seq:
+      #     clapack_gesv(order, n, nrhs, a, lda, ipiv, b, ldb) -> NMatrix
+      #
+      # 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.
+      #
+      # 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.
+      # 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.
+      #
+      # * *Arguments* :
+      #   - +order+ ->
+      #   - +n+ ->
+      #   - +nrhs+ ->
+      #   - +a+ ->
+      #   - +lda+ ->
+      #   - +ipiv+ ->
+      #   - +b+ ->
+      #   - +ldb+ ->
+      # * *Returns* :
+      #   -
+      # * *Raises* :
+      #   - ++ ->
+      #
       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
+      #
+      # call-seq:
+      #     clapack_posv(order, uplo, n ,nrhs, a, lda, b, ldb) -> ...
+      #
+      # TODO Complete this description.
+      #
+      # 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.
@@ -67,9 +97,24 @@ class NMatrix
       #
       # 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.
+      # 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.
+      #
+      # * *Arguments* :
+      #   - +order+ ->
+      #   - +uplo+ ->
+      #   - +n+ ->
+      #   - +nrhs+ ->
+      #   - +a+ ->
+      #   - +lda+ ->
+      #   - +b+ ->
+      #   - +ldb+ ->
+      # * *Returns* :
+      #   -
+      # * *Raises* :
+      #   - ++ ->
+      #
       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)

data/lib/nmatrix/monkeys.rb

@@ -1,3 +1,4 @@
+#--
 # = NMatrix
 #
 # A linear algebra library for scientific computation in Ruby.
@@ -8,8 +9,8 @@
 #
 # == Copyright Information
 #
-# SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
-# NMatrix is Copyright (c) 2012, Ruby Science Foundation
+# SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
+# NMatrix is Copyright (c) 2013, Ruby Science Foundation
 #
 # Please see LICENSE.txt for additional copyright notices.
 #
@@ -23,52 +24,53 @@
 # == 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
+  # 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
+    def max #:nodoc:
       self.inject(self.first) { |m, n| if n > m then n else m end }
     end
   end
 
   unless method_defined?(:min)
-    def min
+    def min #:nodoc:
       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
+class Object #:nodoc:
+  def returning(value)
+    yield(value)
+    value
+  end
 end
 
 class String #:nodoc: