pnmatrix 1.2.4

data/lib/nmatrix/io/harwell_boeing.rb

@@ -0,0 +1,221 @@
+#--
+# = 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 - 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.
+#
+# == 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/harwell_boeing.rb
+#
+# Harwell Boeing file reader (and eventually writer too).
+# => Supports only assembled, non-symmetric, real matrices
+# => Data types supported are exponential, floating point and integer
+# => Returned NMatrix is of type :float64
+#++
+
+require_relative './fortran_format.rb'
+
+class NMatrix
+  module IO
+    module HarwellBoeing
+
+      class << self
+        # Loads the contents of a valid Harwell Boeing format file and 
+        # returns an NMatrix object with the values of the file and optionally
+        # only the header info.
+        # 
+        # Supports only assembled, non-symmetric, real matrices. File name must
+        # have matrix type as extension.
+        # 
+        # Example - test_file.rua
+        # 
+        # == Arguments
+        # 
+        # * +file_path+ - Path of the Harwell Boeing file  to load.
+        # * +opts+      - Options for specifying whether you want
+        #                 the values and  header or only the header.
+        # 
+        # == Options
+        # 
+        # * +:header+ - If specified as *true*, will return only the header of
+        #               the HB file.Will return the NMatrix object and
+        #               header as an array if left blank.
+        # 
+        # == Usage
+        # 
+        #   mat, head = NMatrix::IO::HarwellBoeing.load("test_file.rua")
+        # 
+        #   head = NMatrix::IO::HarwellBoeing.load("test_file.rua", {header: true})
+        # 
+        # == Alternate Usage
+        # 
+        # You can specify the file using NMatrix::IO::Reader.new("path/to/file")
+        # and then call *header* or *values* on the resulting object.
+        def load file_path, opts={}
+          hb_obj = NMatrix::IO::HarwellBoeing::Reader.new(file_path)
+
+          return hb_obj.header if opts[:header]
+
+          [hb_obj.values, hb_obj.header]
+        end
+      end
+
+      class Reader
+        def initialize file_name
+          raise(IOError, "Unsupported file format. Specify file as \
+            file_name.rua.") if !file_name.match(/.*\.[rR][uU][aA]/)
+
+          @file_name   = file_name
+          @header      = {}
+          @body        = nil
+        end
+
+        def header
+          return @header if !@header.empty?
+          @file = File.open @file_name, "r"
+
+          line = @file.gets
+
+          @header[:title] = line[0...72].strip
+          @header[:key]   = line[72...80].strip
+
+          line = @file.gets
+
+          @header[:totcrd] = line[0...14] .strip.to_i
+          @header[:ptrcrd] = line[14...28].strip.to_i
+          @header[:indcrd] = line[28...42].strip.to_i
+          @header[:valcrd] = line[42...56].strip.to_i
+          @header[:rhscrd] = line[56...70].strip.to_i
+
+          raise(IOError, "Right hand sides not supported.") \
+           if @header[:rhscrd] > 0
+
+          line = @file.gets
+
+          @header[:mxtype] = line[0...3]
+
+          raise(IOError, "Currently supports only real, assembled, unsymmetric \
+            matrices.") if !@header[:mxtype].match(/RUA/)
+
+          @header[:nrow]   = line[13...28].strip.to_i
+          @header[:ncol]   = line[28...42].strip.to_i
+          @header[:nnzero] = line[42...56].strip.to_i
+          @header[:neltvl] = line[56...70].strip.to_i
+
+          line = @file.gets
+
+          fortran_reader = NMatrix::IO::FortranFormat::Reader
+
+          @header[:ptrfmt] = fortran_reader.new(line[0...16].strip) .parse
+          @header[:indfmt] = fortran_reader.new(line[16...32].strip).parse
+          @header[:valfmt] = fortran_reader.new(line[32...52].strip).parse
+          @header[:rhsfmt] = fortran_reader.new(line[52...72].strip).parse
+
+          @header
+        end
+
+        def values
+          @header      = header if @header.empty?
+          @file.lineno = 5      if @file.lineno != 5
+          @matrix      = NMatrix.new([ @header[:nrow], @header[:ncol] ], 
+                                      0, dtype: :float64)
+
+          read_column_pointers
+          read_row_indices
+          read_values
+
+          @file.close
+          
+          assemble_matrix
+
+          @matrix
+        end
+
+       private
+
+        def read_column_pointers
+          @col_ptrs  = []
+          pointer_lines     = @header[:ptrcrd]
+          pointers_per_line = @header[:ptrfmt][:repeat]
+          pointer_width     = @header[:ptrfmt][:field_width]
+
+          @col_ptrs = read_numbers :to_i, pointer_lines, pointers_per_line, 
+                                             pointer_width
+
+          @col_ptrs.map! {|c| c -= 1}
+        end
+
+        def read_row_indices
+          @row_indices     = []
+          row_lines        = @header[:indcrd]
+          indices_per_line = @header[:indfmt][:repeat]
+          row_width        = @header[:indfmt][:field_width]
+
+          @row_indices = read_numbers :to_i, row_lines, indices_per_line, 
+                                      row_width
+
+          @row_indices.map! {|r| r -= 1}
+        end
+
+        def read_values
+          @vals = []
+          value_lines = @header[:valcrd]
+          values_per_line = @header[:valfmt][:repeat]
+          value_width    = @header[:valfmt][:field_width]
+
+          @vals = read_numbers :to_f, value_lines, values_per_line, 
+                                  value_width
+        end
+
+        def read_numbers to_dtype, num_of_lines, numbers_per_line, number_width
+          data = []
+
+          num_of_lines.times do 
+            line  = @file.gets
+            index = 0
+
+            numbers_per_line.times do
+              delimiter = index + number_width
+
+              data << line[index...delimiter].strip.send(to_dtype)
+
+              break if line.length <= delimiter
+              index += number_width
+            end
+          end
+
+          data
+        end
+
+        def assemble_matrix
+          col = 0
+          @col_ptrs[0..-2].each_index do |index|
+            @col_ptrs[index].upto(@col_ptrs[index+1] - 1) do |row_ptr|
+              row               = @row_indices[row_ptr]
+              @matrix[row, col] = @vals[row_ptr]
+            end
+
+            col += 1
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/nmatrix/io/market.rb

@@ -0,0 +1,263 @@
+# = 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 - 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.
+#
+# == 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.
+#
+#++
+
+# Matrix Market is a repository of test data for use in studies of algorithms
+# for numerical linear algebra. There are 3 file formats used:
+#
+# - Matrix Market Exchange Format.
+# - Harwell-Boeing Exchange Format.
+# - Coordinate Text File Format. (to be phased out)
+#
+# This module can load and save the first format. We might support
+# Harwell-Boeing in the future.
+#
+# The MatrixMarket format is documented in:
+# * http://math.nist.gov/MatrixMarket/formats.html
+module NMatrix::IO::Market
+  CONVERTER_AND_DTYPE = {
+    :real => [:to_f, :float64],
+    :complex => [:to_c, :complex128],
+    :integer => [:to_i, :int64],
+    :pattern => [:to_i, :byte]
+  } #:nodoc:
+
+  ENTRY_TYPE = {
+    :byte => :integer, :int8 => :integer, :int16 => :integer,
+    :int32 => :integer, :int64 => :integer,:float32 => :real,
+    :float64 => :real, :complex64 => :complex, :complex128 => :complex
+  } #:nodoc:
+
+  class << self
+
+    # call-seq:
+    #     load(filename) -> NMatrix
+    #
+    # Load a MatrixMarket file. Requires a +filename+ as an argument.
+    #
+    # * *Arguments* :
+    #   - +filename+ -> String with the filename to be saved.
+    # * *Raises* :
+    #   - +IOError+ -> expected type code line beginning with '%%MatrixMarket matrix'
+    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
+
+    # call-seq:
+    #     save(matrix, filename, options = {}) -> true
+    #
+    # 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.
+    #
+    # * *Arguments* :
+    #   - +matrix+ -> NMatrix with the data to be saved.
+    #   - +filename+ -> String with the filename to be saved.
+    # * *Raises* :
+    #   - +DataTypeError+ -> MatrixMarket does not support Ruby objects.
+    #   - +ArgumentError+ -> Expected two-dimensional NMatrix.
+    def save(matrix, filename, options = {})
+      options = {:pattern => false,
+        :symmetry => :general}.merge(options)
+
+      mode = matrix.stype == :dense ? :array : :coordinate
+      if [:object].include?(matrix.dtype)
+        raise(DataTypeError, "MatrixMarket does not support 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 = 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/point_cloud.rb

@@ -0,0 +1,189 @@
+#--
+# = 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 - 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.
+#
+# == 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 Point Cloud Data (PCD) file format.
+#
+# The documentation of this format can be found in:
+#
+# http://pointclouds.org/documentation/tutorials/pcd_file_format.php
+#
+# Note that this implementation does not take the width or height parameters
+# into account.
+module NMatrix::IO::PointCloud
+
+  # For UINT, just add 1 to the index.
+  INT_DTYPE_BY_SIZE   = [:int8, :int8, :int16, :int32, :int64, :int64] #:nodoc:
+  FLOAT_DTYPE_BY_SIZE = {4 => :float32, 8 => :float64} #:nodoc:
+
+  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
+
+  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]
+
+    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
+        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
+      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
+      @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
+end

data/lib/nmatrix/jruby/decomposition.rb

@@ -0,0 +1,24 @@
+class NMatrix
+
+  # discussion in https://github.com/SciRuby/nmatrix/issues/374
+
+  def matrix_solve rhs
+    if rhs.shape[1] > 1
+      nmatrix = NMatrix.new :copy
+      nmatrix.shape = rhs.shape
+      res = []
+      #Solve a matrix and store the vectors in a matrix
+      (0...rhs.shape[1]).each do |i|
+        res << self.solve(rhs.col(i)).s.toArray.to_a
+      end
+      #res is in col major format
+      result = ArrayGenerator.getArrayColMajorDouble res.to_java :double, rhs.shape[0], rhs.shape[1]
+      nmatrix.s = ArrayRealVector.new result
+
+      return nmatrix
+    else
+      return self.solve rhs
+    end
+  end
+
+end

data/lib/nmatrix/jruby/enumerable.rb

@@ -0,0 +1,13 @@
+# Source: https://github.com/marcandre/backports/blob/master/lib/backports/rails/enumerable.rb
+module Enumerable
+  # Standard in rails... See official documentation[http://api.rubyonrails.org/classes/Enumerable.html]
+  # Modified from rails 2.3 to not rely on size
+  def sum(identity = 0, &block)
+    if block_given?
+      map(&block).sum(identity)
+    else
+      inject { |sum, element| sum + element } || identity
+    end
+  end unless method_defined? :sum
+
+end