stair_car 0.0.1

data/lib/stair_car/pmatrix/pmatrix.rb

@@ -0,0 +1,151 @@
+require File.dirname(__FILE__) + '/../../pcolt/parallelcolt-0.9.4'
+require 'stair_car/pmatrix/types'
+require 'stair_car/pmatrix/matrix_math'
+require 'stair_car/pmatrix/transforms'
+require 'stair_car/pmatrix/compare'
+require 'stair_car/shared/iteration'
+require 'stair_car/shared/inspect'
+require 'stair_car/shared/indicies'
+require 'stair_car/shared/init_methods'
+require 'stair_car/shared/errors'
+
+
+module StairCar
+  class PMatrix
+    include PMatrixTypes
+    include PMatrixMatrixMath
+    include PMatrixTransforms
+    include PMatrixCompare
+    include Iteration
+    include Inspect
+    include Indicies
+    include InitMethods
+
+    attr_accessor :data
+
+    # Proxy methods
+    [:size, :rows].each do |method_name|
+      define_method(method_name) do |*args|
+        @data.send(method_name, *args)
+      end
+    end
+
+    def cols
+      @data.columns
+    end
+
+    def shape
+      [rows, cols]
+    end
+
+
+    def initialize(rows_or_data=nil, cols=nil, type=:double, sparse=false, initialize_values=:zeros)
+      if rows_or_data.is_a?(Array)
+        klass = type_class(type, sparse, initialize_values)
+
+        # Create the matrix from an array
+        from_array(rows_or_data, klass)
+      elsif rows_or_data.is_a?(Fixnum)
+        raise MatrixDimensionsError, "Must specify columns and rows" unless rows_or_data && cols
+        klass = type_class(type, sparse, initialize_values)
+        if klass.is_a?(Method) || klass.is_a?(Proc)
+          # A factory method was returned, call to build
+          @data = klass.call(rows_or_data, cols)
+        else
+          # A class was returned, create new
+          @data = klass.new(rows_or_data, cols)
+
+          setup_default_values(initialize_values)
+        end
+      else
+        # Passing in data directly
+        @data = rows_or_data
+      end
+    end
+
+    def setup_default_values(initialize_values)
+      if initialize_values == :ones
+        @data.assign(1.0)
+      end
+    end
+
+    def [](rows, cols)
+      rows = convert_indicies(rows, self.rows)
+      cols = convert_indicies(cols, self.cols)
+
+      # Returns either the value in a cell or a subview
+      if rows && cols && rows.size == 1 && cols.size == 1 && rows.first.is_a?(Fixnum) && cols.first.is_a?(Fixnum)
+        @data.get(rows.first, cols.first)
+      else
+        # Get subview, also convert rows/cols to java arrays
+        self.class.new(@data.view_selection(rows && rows.to_java(:int), cols && cols.to_java(:int)))
+      end
+    end
+
+    def []=(rows, cols, value)
+      rows = convert_indicies(rows, self.rows)
+      cols = convert_indicies(cols, self.cols)
+
+      # Set either the value in a cell or a subview with a matrix
+      if rows && cols && rows.size == 1 && cols.size == 1 && rows.first.is_a?(Fixnum) && cols.first.is_a?(Fixnum)
+        @data.set(rows.first, cols.first, value)
+      else
+        subview = @data.view_selection(rows && rows.to_java(:int), cols && cols.to_java(:int))
+
+        # Assign a single array or a nested array
+        if value.is_a?(Array)
+          value_rows, value_cols = array_dimensions(value)
+
+          # If one dimentional, and they want to set cols
+          if value_rows == 1 && subview.columns == 1
+            # Transpose so we can place an array vertically
+            subview = subview.view_dice
+          end
+
+          # Check to make sure the sizes match
+          if value_rows != subview.rows || value_cols != subview.columns
+            raise MatrixDimensionsError, "the array you are trying to assign is not the correct size"
+          end
+        end
+
+        if value.is_a?(PMatrix)
+          value = value.data
+        end
+
+        if value.is_a?(Array)
+          assign_values(subview, value)
+        else
+          subview.assign(value)
+        end
+      end
+    end
+
+
+    # Loop through each non-zero value, pass in the value, row, column
+    def each_non_zero(&block)
+      @data.for_each_non_zero do |row, col, value|
+        yield(value, row, col)
+
+        value
+      end
+    end
+
+
+    # Takes an array and assigns it to the right cells in the subview
+    def assign_values(subview, value)
+      unless value.first.is_a?(Array)
+        value = [value]
+      end
+
+      value.each_with_index do |row,row_index|
+        row.each_with_index do |val,col_index|
+          subview.set(row_index, col_index, val.to_java(:double))
+        end
+      end
+    end
+
+    def dup
+      PMatrix.new(@data.copy)
+    end
+  end
+end

data/lib/stair_car/pmatrix/transforms.rb

@@ -0,0 +1,74 @@
+module StairCar
+  module PMatrixTransforms
+    def transpose
+      return PMatrix.new(@data.view_dice.copy)
+    end
+
+    def ~
+      return transpose
+    end
+
+    def inv
+      algebra = Java::cern.colt.matrix.tdouble.algo.DenseDoubleAlgebra.new
+      begin
+        return PMatrix.new(algebra.inverse(@data))
+      rescue Java::JavaLang::IllegalArgumentException => e
+        if e.message == 'Matrix is singular.' || e.message == 'A is singular.'
+          raise InverseMatrixIsSignular, e.message
+        else
+          raise
+        end
+      end
+    end
+
+    def map(&block)
+      dup.map!(&block)
+    end
+
+    def map!
+      result = self.each_with_index do |val,row,col|
+        self[row,col] = yield(val, row, col)
+      end
+
+      return self
+    end
+
+    def map_non_zero(&block)
+      dup.map_non_zero!(&block)
+    end
+
+    def map_non_zero!
+      result = @data.for_each_non_zero do |row,col,val|
+        yield(val, row, col)
+      end
+
+      PMatrix.new(result)
+    end
+
+    def count
+      count = 0
+
+      each do |val,row,col|
+        if yield(val,row,col)
+          count += 1
+        end
+      end
+
+      return count
+    end
+
+    # Converts the matrix into an array
+    def to_a
+      array = []
+      rows.times do |row|
+        col_array = []
+        cols.times do |col|
+          col_array << self[row,col]
+        end
+        array << col_array
+      end
+
+      return array
+    end
+  end
+end

data/lib/stair_car/pmatrix/types.rb

@@ -0,0 +1,106 @@
+# Lookup the type for the underlying matrix implementation
+module StairCar
+  module PMatrixTypes
+
+    def type
+      klass = @data.class
+      if klass == Java::CernColtMatrixTdoubleImpl::DenseDoubleMatrix2D
+        return :double
+      elsif klass == Java::CernColtMatrixTdoubleImpl::SparseDoubleMatrix2D
+        return :double
+      elsif klass == Java::CernColtMatrixTfloatImpl::DenseFloatMatrix2D
+        return :float
+      elsif klass == Java::CernColtMatrixTfloatImpl::SparseFloatMatrix2D
+        return :float
+      end
+    end
+
+    def sparse?
+      klass = @data.class
+      if klass == Java::CernColtMatrixTdoubleImpl::DenseDoubleMatrix2D
+        return false
+      elsif klass == Java::CernColtMatrixTdoubleImpl::SparseDoubleMatrix2D
+        return true
+      elsif klass == Java::CernColtMatrixTfloatImpl::DenseFloatMatrix2D
+        return false
+      elsif klass == Java::CernColtMatrixTfloatImpl::SparseFloatMatrix2D
+        return true
+      end
+    end
+
+
+    def type_class(type, sparse, initialize_values)
+      types = {
+        :zeros => {
+          false => {
+            # dense
+            :double => Java::cern.colt.matrix.tdouble.impl.DenseDoubleMatrix2D,
+            :float => Java::cern.colt.matrix.tfloat.impl.DenseFloatMatrix2D
+          },
+          true => {
+            # sparse
+            :double => Java::cern.colt.matrix.tdouble.impl.SparseDoubleMatrix2D,
+            # :double => Proc.new {|rows,cols| Java::cern.colt.matrix.tdouble.impl.SparseDoubleMatrix2D.new(rows,cols,10000.to_java(:int),0.0.to_java(:double),0.999999999.to_java(:double)) },
+            :float => Java::cern.colt.matrix.tfloat.impl.SparseFloatMatrix2D
+          }
+        },
+        :ones => {
+          false => {
+            # dense
+            :double => Java::cern.colt.matrix.tdouble.impl.DenseDoubleMatrix2D,
+            :float => Java::cern.colt.matrix.tfloat.impl.DenseFloatMatrix2D
+          },
+          true => {
+            # sparse
+            :double => Java::cern.colt.matrix.tdouble.impl.SparseDoubleMatrix2D,
+            :float => Java::cern.colt.matrix.tfloat.impl.SparseFloatMatrix2D
+          }
+        },
+        :rand => {
+          false => {
+            # dense
+            :double => Java::cern.colt.matrix.tdouble.DoubleFactory2D.dense.method(:random),
+            :float => Java::cern.colt.matrix.tfloat.FloatFactory2D.dense.method(:random)
+          },
+          true => {
+            # sparse
+            :double => Java::cern.colt.matrix.tdouble.DoubleFactory2D.sparse.method(:random),
+            :float => Java::cern.colt.matrix.tfloat.FloatFactory2D.sparse.method(:random)
+          }
+        },
+        :desc => {
+          false => {
+            # dense
+            :double => Java::cern.colt.matrix.tdouble.DoubleFactory2D.dense.method(:descending),
+            :float => Java::cern.colt.matrix.tfloat.FloatFactory2D.dense.method(:descending)
+          },
+          true => {
+            # sparse
+            :double => Java::cern.colt.matrix.tdouble.DoubleFactory2D.sparse.method(:descending),
+            :float => Java::cern.colt.matrix.tfloat.FloatFactory2D.sparse.method(:descending)
+          }
+        },
+        :asc => {
+          false => {
+            # dense
+            :double => Java::cern.colt.matrix.tdouble.DoubleFactory2D.dense.method(:ascending),
+            :float => Java::cern.colt.matrix.tfloat.FloatFactory2D.dense.method(:ascending)
+          },
+          true => {
+            # sparse
+            :double => Java::cern.colt.matrix.tdouble.DoubleFactory2D.sparse.method(:ascending),
+            :float => Java::cern.colt.matrix.tfloat.FloatFactory2D.sparse.method(:ascending)
+          }
+        }
+      }
+
+      klass = types[initialize_values][sparse][type]
+
+      unless klass
+        raise "Could not make a #{sparse ? 'sparse' : 'dense'} #{type} matrix"
+      end
+
+      return klass
+    end
+  end
+end

data/lib/stair_car/shared/errors.rb

@@ -0,0 +1,7 @@
+module StairCar
+  class MatrixDimensionsError < RuntimeError
+  end
+
+  class InverseMatrixIsSignular < RuntimeError
+  end
+end

data/lib/stair_car/shared/indicies.rb

@@ -0,0 +1,33 @@
+# Handles converting indicies into arrays of row or column offsets
+module StairCar
+  module Indicies
+    def convert_indicies(index, max_index)
+      if index.is_a?(Fixnum)
+        if index < 0
+          return [max_index + index]
+        else
+          return [index]
+        end
+      elsif index.is_a?(Array)
+        # Map to indicies and convert into one array
+        return index.map {|i| convert_indicies(i, max_index) }.flatten
+      elsif index.is_a?(Range)
+        if index.end < 0
+          start = index.begin
+          new_end = max_index + index.end
+
+          # Recreate with the end value
+          if index.exclude_end?
+            index = (start...new_end)
+          else
+            index = (start..new_end)
+          end
+        end
+
+        return index.to_a
+      elsif index.is_a?(NilClass)
+        return nil.to_java#convert_indicies(0...max_index, max_index)
+      end
+    end
+  end
+end

data/lib/stair_car/shared/init_methods.rb

@@ -0,0 +1,56 @@
+module StairCar
+  module InitMethods
+    def from_array(array, klass)
+      rows, cols = array_dimensions(array)
+
+      if klass.is_a?(Method) || klass.is_a?(Proc)
+        @data = klass.call(rows, cols)
+      else
+        @data = klass.new(rows, cols)
+      end
+      self[nil,nil] = array
+    end
+
+
+    def array_dimensions(array)
+      if array.first.is_a?(Array)
+        # Nested array
+        rows = array.size
+        cols = array.first.size
+      else
+        # 1 dimensional array
+        cols = array.size
+        rows = 1
+      end
+
+      return rows, cols
+    end
+
+    module ClassMethods
+      def init_method_names
+        [true, false].each do |sparse|
+          [:double, :float].each do |type|
+            [:zeros, :ones, :rand, :desc, :asc].each do |initialize_values|
+              method_name = :"#{sparse ? 'sp' : ''}#{initialize_values}#{type == :float ? 'f' : ''}"
+
+              yield(method_name, sparse, type, initialize_values)
+            end
+          end
+        end
+
+        # Also add float and double shortcuts
+        yield(:float, false, :float, :zeros)
+        yield(:double, false, :float, :zeros)
+      end
+    end
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+      klass.init_method_names do |method_name, sparse, type, initialize_values|
+        klass.define_singleton_method(method_name) do |cols, rows|
+          klass.new(cols, rows, type, sparse, initialize_values)
+        end
+      end
+    end
+  end
+end

data/lib/stair_car/shared/inspect.rb

@@ -0,0 +1,113 @@
+module StairCar
+  module Inspect
+    def inspect(screen_width = 80, rows_to_show=12)
+      lines = []
+      lines << "<#PMatrix(#{type}) #{rows}x#{cols} #{sparse? ? 'sparse' : 'dense'}>"
+
+      # To print cleanly, we should make the rows as big as the max width
+      # cell.  We greedly loop through the columns and keep track of where
+      # we are.
+      formatter = Proc.new { |number| sprintf('%.3f', number).gsub(/[.]?0+$/, '') }
+
+      # Sometimes we only have a 1x1 matrix, and lookups will return a float
+      if rows == 1 && cols == 1
+        lines << formatter.call(self[0,0])
+        return lines.join("\n")
+      end
+
+      # Max rows, minus the last row
+      max_rows = [rows_to_show-1, rows].min
+
+      # We need to find the biggest cell we're going to need to display.  So
+      # we grab the last row, then all of the other rows, by the last column,
+      # followed by all of the other columns.  We go down columns until we go
+      # past the screen width.
+      cell_width = self[[-1,0...(max_rows-1)],[-1,0...(cols-1)]].max_char_width(formatter, max_rows, screen_width)
+
+      # Compute how many columns we can show in the screen area, min with cols
+      # incase we could fit more than we have
+      max_columns = (screen_width / cell_width).floor
+      if max_columns >= self.cols
+        # We can display all of the cells, set the screen width to the new width
+        hidden_columns = false
+        screen_width = (cell_width * self.cols) - 1
+      else
+        # We can't fit all cells, hide the columns
+        hidden_columns = true
+        max_columns = ((screen_width - 3 - cell_width) / cell_width).floor
+      end
+
+      # See if we need to hide rows
+      hidden_rows = (self.rows > max_rows)
+
+      # Add all rows, except the last
+      [max_rows, self.rows-1].min.times do |row|
+        lines << row_line_text(row, formatter, max_columns, screen_width, cell_width, hidden_columns)
+      end
+
+      # Put a line in saying how rows we've hidden
+      if hidden_rows
+        lines << "#{self.rows - max_rows} rows".center(screen_width, '.')
+      end
+
+      # Say how many rows we're leaving out
+      if hidden_columns
+        # Go in and replace the .'s with text
+        message = "#{self.cols - max_columns} cols".center(max_rows, '.')
+
+        # convert message to an array
+        message = message.split(//)
+        (max_rows-1).times do |row|
+          next_char = message.slice!(0)
+          break unless next_char
+          lines[row+1][(cell_width + 2) * -1] = next_char
+        end
+      end
+
+      # Add last row
+      lines << row_line_text(-1, formatter, max_columns, screen_width, cell_width, hidden_columns)
+
+      return lines.join("\n")
+    end
+
+    # Figure out how big the cells should be, stop early when we reach the
+    # end of the screen
+    def max_char_width(formatter, max_rows, max_char_width)
+      max_cell_width = 0
+      rows.times do |row|
+        cols.times do |column|
+          cell_value = self[row, column]
+          width = formatter.call(cell_value).size + 1
+
+          # Track the biggest cell width we've seen so far
+          max_cell_width = width if width > max_cell_width
+
+          if max_cell_width * column > max_char_width
+            # We have now passed the width of the screen or section, break
+            #  to next row
+            break
+          end
+        end
+      end
+
+      return max_cell_width
+    end
+
+    private
+      def row_line_text(row_number, formatter, max_columns, screen_width, cell_width, hidden_columns)
+        line = ''
+        [self.cols-1, max_columns].min.times do |column|
+          cell_value = self[row_number, column]
+          line << formatter.call(cell_value).ljust(cell_width)
+        end
+
+        last_cell = formatter.call(self[row_number, -1]).ljust(cell_width-1)
+        padding_size = screen_width - line.size - last_cell.size - 1
+        line << ('.' * padding_size) + ' ' if hidden_columns
+
+        line << last_cell
+
+        return line
+      end
+  end
+end

data/lib/stair_car/shared/iteration.rb

@@ -0,0 +1,32 @@
+module StairCar
+  module Iteration
+    def each(&block)
+      rows.times do |row|
+        cols.times do |col|
+          yield(self[row,col])
+        end
+      end
+    end
+
+    def each_with_index(&block)
+      rows.times do |row|
+        cols.times do |col|
+          yield(self[row,col], row, col)
+        end
+      end
+    end
+
+    def each_column
+      cols.times do |col_number|
+        yield(self[nil,col_number],col_number)
+      end
+    end
+
+    def each_row
+      rows.times do |row_number|
+        yield(self[row_number,nil],row_number)
+      end
+    end
+
+  end
+end

data/lib/stair_car/umatrix/compare.rb

@@ -0,0 +1,34 @@
+module StairCar
+  module UMatrixCompare
+    # def >(val)
+    #  map {|v| (v > val) ? 1 : 0 }
+    # end
+    #
+    # def >=(val)
+    #   map {|v| (v >= val) ? 1 : 0 }
+    # end
+    #
+    # def <(val)
+    #  map {|v| (v < val) ? 1 : 0 }
+    # end
+    #
+    # def <=(val)
+    #   map {|v| (v <= val) ? 1 : 0 }
+    # end
+    #
+    # def find(matrix)
+    #
+    # end
+    #
+    # def any?
+    #   @data.cardinality > 0
+    # end
+
+
+    # Compares this matrix to another to see if they are the same (in values)
+    def ==(matrix2)
+      self.data.equalsContent(matrix2.data)
+    end
+
+  end
+end