stair_car 0.0.1

data/lib/stair_car/umatrix/matrix_math.rb

@@ -0,0 +1,190 @@
+module StairCar
+  module UMatrixMatrixMath
+    class MatrixMathError < RuntimeError
+    end
+
+    # In jruby, we need to pass the params to java_methods to distinguish them
+    # when multiple java methods (with different params) have the same name.
+    def find_params(object, method_name, &search)
+      while object
+        object.declared_instance_methods.each do |method|
+          if method.name == method_name
+            if yield(method.parameter_types)
+              # Method checks to see if the parameter types are correct, if they
+              # are then we return them.
+              return method.parameter_types
+            end
+          end
+        end
+
+        # If we didn't find it here, move up the chain
+        object = object.superclass
+      end
+
+      return nil
+    end
+
+    def perform(method, val)
+      method = method.to_s
+      result = @data.clone
+      if val.is_a?(UMatrix)
+        @param_types ||= {}
+        @param_types[method] ||= find_params(result.java_class, method) do |params|
+          # params.first.name == 'org.ujmp.core.Matrix'
+          params.size == 3 &&
+          params[0].name == 'org.ujmp.core.calculation.Calculation$Ret' &&
+          params[1].name == 'boolean' &&
+          params[2].name == 'org.ujmp.core.Matrix'
+        end
+        if rows == val.rows && cols == val.cols
+          # Another matrix of the same size
+          # result = result.java_send(method, @param_types[method], val.data)
+          result.java_send(method, @param_types[method], Java::OrgUjmpCoreCalculation::Calculation.ORIG, false.to_java, val.data)
+        elsif rows == val.rows && val.cols == 1
+          # Vector on column (vertical)
+          UMatrix.new(result).each_column do |row|
+            # row.data.send(method, Java::OrgUjmpCoreCalculation::Calculation.ORIG, false.to_java, val.data)
+            # row.data.java_send(method, @param_types[method], val.data)
+            row.data.java_send(method, @param_types[method], Java::OrgUjmpCoreCalculation::Calculation.ORIG, false.to_java, val.data)
+          end
+        elsif cols == val.cols && val.rows == 1
+          # Vector on rows (horizontal)
+          UMatrix.new(result).each_row do |col|
+            col.data.java_send(method, @param_types[method], Java::OrgUjmpCoreCalculation::Calculation.ORIG, false.to_java, val.data)
+            # col.data.send(method, Java::OrgUjmpCoreCalculation::Calculation.ORIG, false.to_java, val.data)
+          end
+        else
+          # Incorrect size
+          raise MatrixMathError, "matrix dimensions incorrect"
+        end
+      else
+        # Passed in a number
+        result = result.send(method, Java::OrgUjmpCoreCalculation::Calculation.ORIG, false.to_java, val.to_java(:double))
+      end
+
+      return UMatrix.new(result)
+    end
+
+    def +(val)
+      perform(:plus, val)
+    end
+
+    def -(val)
+      perform(:minus, val)
+    end
+
+    def **(val)
+    end
+
+    def /(val)
+    end
+
+    def *(val)
+      n = self.rows
+      m = self.cols
+
+      p = val.rows
+      q = val.cols
+
+      if m != p
+        raise MatrixMathError, "matricies can not be multiplied"
+      end
+
+      # Build a like matrix to receive
+      c = @data.like(n, q)
+
+      @data.z_mult(val.data, c)
+
+      return UMatrix.new(c)
+    end
+
+    # ujmp requires you pass in a special code for all dimensions
+    def dim_convert(dimension)
+      if dimension == nil
+        dimension = Java::org.ujmp.core.Matrix::ALL
+      end
+
+      return dimension
+    end
+
+    # Calls aggraration method on the data
+    def call_data_method(method, dimension, *args)
+      result = UMatrix.new(@data.send(method, Java::OrgUjmpCoreCalculation::Calculation.NEW, dim_convert(dimension), *args))
+      if dimension
+        return result
+      else
+        # Just return the first element
+        return result[0,0]
+      end
+    end
+
+    def sum(dimension=nil)
+      return call_data_method(:sum, dimension, false)
+    end
+
+    def max(dimension=nil)
+      return call_data_method(:max, dimension)
+    end
+
+    def min(dimension=nil)
+      return call_data_method(:min, dimension)
+    end
+
+    def mean(dimension=nil)
+      return call_data_method(:mean, dimension, false)
+    end
+
+    def variance(dimension=nil, sample=false)
+      if dimension
+        value = aggrate_on_dimension(:variance, dimension, sample)
+      else
+        mean = self.mean
+        total = 0
+        self.each_non_zero do |v|
+          total += (mean - v) ** 2
+        end
+
+        if sample
+          value = total / (self.size - 1)
+        else
+          value = total / self.size
+        end
+      end
+
+      return value
+    end
+
+    def std(dimension=nil, sample=false)
+      if dimension
+        value = aggrate_on_dimension(:variance, dimension, sample)
+      else
+        value = Math.sqrt(self.variance(dimension, sample))
+      end
+
+      return value
+    end
+
+    private
+      def aggrate_on_dimension(method_name, dimension, *args)
+        if dimension == 0
+          # Get the per row
+          vals = UMatrix.new(@data.like(rows, 1))
+
+          self.each_row do |row, row_number|
+            vals[row_number,0] = row.send(method_name, nil, *args).to_f
+          end
+
+          return vals
+        elsif dimension == 1
+          # Get the per row
+          vals = UMatrix.new(@data.like(1, cols))
+
+          self.each_column do |col, col_number|
+            vals[0,col_number] = col.send(method_name, nil, *args).to_f
+          end
+
+          return vals
+        end
+      end
+  end
+end

data/lib/stair_car/umatrix/transforms.rb

@@ -0,0 +1,49 @@
+module StairCar
+  module UMatrixTransforms
+    def transpose
+      return UMatrix.new(@data.transpose)
+    end
+
+    def ~
+      return transpose
+    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!
+      each_non_zero do |val,row,col|
+        self[row,col] = yield(val, row, col)
+      end
+
+      return self
+    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/umatrix/types.rb

@@ -0,0 +1,42 @@
+# Lookup the type for the underlying matrix implementation
+module StairCar
+  module UMatrixTypes
+
+    def type
+      return :double
+    end
+
+    def sparse?
+      @data.sparse?
+    end
+
+
+    def type_class(type, sparse, initialize_values)
+      if sparse
+        base = Java::org.ujmp.parallelcolt::ParallelColtSparseDoubleMatrix2D
+      else
+        base = Java::org.ujmp.core.Matrix.factory
+      end
+
+      # if sparse
+      #   base = Java::org.ujmp.core.matrix.SparseMatrix.factory
+      # else
+      #   base = Java::org.ujmp.core.Matrix.factory
+      # end
+
+      if [:zeros, :ones, :rand, :desc, :asc].include?(initialize_values)
+        if [:asc, :desc].include?(initialize_values)
+          initialize_values = :zeros
+        end
+
+        if sparse && initialize_values == :zeros
+          initialize_values = :new
+        end
+
+        return Proc.new { |rows, cols| base.send(initialize_values, rows, cols) }
+      else
+        raise "Type is not valid"
+      end
+    end
+  end
+end

data/lib/stair_car/umatrix/umatrix.rb

@@ -0,0 +1,166 @@
+require File.dirname(__FILE__) + '/../../pcolt/parallelcolt-0.9.4'
+require File.dirname(__FILE__) + '/../../ujmp/ujmp-complete-0.2.5'
+
+require 'stair_car/umatrix/types'
+require 'stair_car/umatrix/matrix_math'
+require 'stair_car/umatrix/transforms'
+require 'stair_car/umatrix/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 UMatrix
+    include UMatrixTypes
+    # include Indicies
+    include UMatrixMatrixMath
+    include UMatrixTransforms
+    include UMatrixCompare
+    include Iteration
+    include Inspect
+    include Indicies
+    include InitMethods
+
+    attr_accessor :data
+
+    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)
+        end
+
+        setup_default_values(initialize_values)
+      else
+        # Passing in data directly
+        @data = rows_or_data
+      end
+    end
+
+    def setup_default_values(initialize_values)
+      if initialize_values == :asc
+        i = 0
+        self.map! do |val,row,col|
+          self[row,col] = i
+          i += 1
+        end
+      elsif initialize_values == :desc
+        i = size
+        self.map! do |val,row,col|
+          self[row,col] = i
+          i -= 1
+        end
+      end
+    end
+
+
+    def shape
+      rows, cols = data.size
+
+      return [rows, cols]
+    end
+
+    def size
+      rows, cols = shape
+      return rows * cols
+    end
+
+    def rows
+      return shape[0]
+    end
+
+    def cols
+      return shape[1]
+    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)
+        if @data.is_a?(Java::org.ujmp.core.objectmatrix.impl.ObjectCalculationMatrix)
+          @data.getObject(rows.first.to_java(:int), cols.first.to_java(:int)) || 0.0
+        else
+          # From jruby we have to call this way for doubles
+          @data.java_send(:getObject, [Java::long, Java::long], rows.first, cols.first) || 0.0
+        end
+      else
+        # Get subview, also convert rows/cols to java arrays
+        if !rows && !cols
+          return self.class.new(@data)
+        else
+          if rows
+            return self.class.new(@data.select(Java::OrgUjmpCoreCalculation::Calculation.LINK, rows, cols))
+          else
+            # If row is nil, we need to lookup by columns directly
+            return self.class.new(@data.select_columns(Java::OrgUjmpCoreCalculation::Calculation.LINK, cols))
+          end
+        end
+      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.setObject(value.to_java(:double), rows.first, cols.first)
+      else
+        subview = self[rows, cols]
+
+        # 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.cols == 1
+            # Transpose so we can place an array vertically
+            subview = subview.transpose
+          end
+
+          # Check to make sure the sizes match
+          if value_rows != subview.rows || value_cols != subview.cols
+            raise MatrixDimensionsError, "the array you are trying to assign is not the correct size"
+          end
+        end
+
+        # value = convert_value(value)
+        unless value[0].is_a?(Array)
+          value = [value]
+        end
+
+        value.each_with_index do |row,row_index|
+          row.each_with_index do |cell,col_index|
+            subview[row_index, col_index] = cell
+          end
+        end
+      end
+    end
+
+    # Loop through each non-zero value, pass in the value, row, column
+    def each_non_zero(&block)
+      @data.available_coordinates.each do |row, col|
+        val = self[row,col]
+        yield(val, row, col)
+      end
+    end
+
+    def dup
+      UMatrix.new(@data.clone)
+    end
+  end
+end

data/lib/stair_car.rb

@@ -0,0 +1,35 @@
+require 'java'
+require 'stair_car/pmatrix/pmatrix'
+require 'stair_car/umatrix/umatrix'
+
+module StairCar
+  def self.included(klass)
+    # Add easy access methods
+    PMatrix.init_method_names do |method_name, sparse, type, initialize_values|
+      klass.send(:define_method, method_name) do |cols, rows|
+        PMatrix.new(cols, rows, type, sparse, initialize_values)
+      end
+    end
+  end
+
+  def to_java_nested_array(array, type=:double)
+    if type == :double
+      type = java.lang.Double::TYPE
+    else
+      type = java.lang.Float::TYPE
+    end
+
+    rows = array.size
+    cols = array[0].size
+
+    java_array = java.lang.reflect.Array.newInstance(type, [rows,cols].to_java(:int))
+
+    rows.times do |row|
+      cols.times do |col|
+        java_array[row][col] = array[row][col]
+      end
+    end
+
+    return java_array
+  end
+end

data/spec/pmatrix/matrix_math_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'stair_car'
+
+describe StairCar::PMatrixMatrixMath do
+  before(:all) do
+    @a = StairCar::PMatrix.asc(5,5)
+    @b = StairCar::PMatrix.asc(5,5)
+  end
+
+  it 'should add matricies' do
+    c = @a + @b
+    c[0,0].should == 2
+  end
+
+  it 'should add scalars' do
+    c = @a + 5
+    # Should copy
+    @a[0,0].should == 1
+
+    c[0,0].should == 6
+  end
+
+  it 'should add vectors' do
+    c = StairCar::PMatrix.new([[1,2,3,4,5]])
+    # (@a + c).should == StairCar::PMatrix.new([[2,4,6,8,10]])
+  end
+
+
+  it 'should sum all' do
+    matrix = StairCar::PMatrix.asc(3,3)
+    matrix.sum.should == 45
+  end
+
+  it 'should sum columns' do
+    matrix = StairCar::PMatrix.asc(3,5)
+    matrix.sum(0).should == StairCar::PMatrix.new([[18, 21, 24, 27, 30]])
+  end
+
+  it 'should get the max on columns or rows' do
+    matrix = StairCar::PMatrix.asc(3,5)
+    matrix.max(1).should == StairCar::PMatrix.new([[5],[10],[15]])
+    matrix.max(0).should == StairCar::PMatrix.new([[11, 12, 13, 14, 15]])
+  end
+
+  it 'should get the mins on columns or rows' do
+    matrix = StairCar::PMatrix.asc(3,5)
+    matrix.min(1).should == StairCar::PMatrix.new([[1],[6],[11]])
+    matrix.min(0).should == StairCar::PMatrix.new([[1, 2, 3, 4, 5]])
+  end
+
+  it "should return the mean on each dimension" do
+    matrix = StairCar::PMatrix.asc(3,5)
+    matrix.mean.should == 8.0
+    matrix.mean(1).should == StairCar::PMatrix.new([[3],[8],[13]])
+    matrix.mean(0).should == StairCar::PMatrix.new([[6, 7, 8, 9, 10]])
+  end
+
+  it "should return the variance" do
+
+  end
+
+  it "should return the standard deviation" do
+
+  end
+end

data/spec/pmatrix/pmatrix_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+require 'stair_car'
+
+describe StairCar::PMatrix do
+  it "should initialize" do
+    matrix = StairCar::PMatrix.zeros(5,4)
+    matrix.cols.should == 4
+    matrix.rows.should == 5
+    matrix.size.should == 20
+
+    matrix = StairCar::PMatrix.spzeros(5,4)
+    matrix.size.should == 20
+  end
+
+  it "should initialize with values" do
+    matrix1 = StairCar::PMatrix.new([[3,8,13]])
+    matrix1[0,0].should == 3
+    matrix1[0,2].should == 13
+
+    matrix2 = StairCar::PMatrix.new([[3],[8],[13]])
+    matrix2[0,0].should == 3
+    matrix2[2,0].should == 13
+  end
+
+  it "should set and get" do
+    matrix = StairCar::PMatrix.zeros(3,4)
+    matrix[0,0] = 5
+    matrix[0,0].should == 5
+  end
+
+  it 'should assign a matrix to a subview' do
+    matrix = StairCar::PMatrix.asc(3,3)
+    s = matrix[0,nil]
+    matrix[1,nil] = s
+  end
+
+  it "should set via arrays" do
+    matrix = StairCar::PMatrix.zeros(3,4)
+    matrix[0,nil] = [1,2,3,4]
+    matrix[0,nil].should == StairCar::PMatrix.new([1,2,3,4])
+    matrix[nil,0] = [1,2,3]
+    matrix[nil,nil] = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
+  end
+
+  it "should raise an error when trying to assign an array with invalid dimensions" do
+    matrix = StairCar::PMatrix.zeros(3,4)
+
+    lambda {
+      matrix[0,nil] = [1,2,3,4,5,6]
+    }.should raise_error(StairCar::MatrixDimensionsError)
+  end
+
+  it "should get and set with negative values" do
+    matrix = StairCar::PMatrix.zeros(5,4)
+    matrix[4,3] = 5
+    matrix[-1,-1].should == 5
+  end
+
+  it "should allow you to setup ones" do
+    matrix = StairCar::PMatrix.ones(5,5)
+    matrix[2,2].should == 1
+  end
+
+
+  it 'should compare matrix values' do
+    matrix1 = StairCar::PMatrix.asc(3,3)
+    matrix2 = StairCar::PMatrix.asc(3,3)
+    matrix3 = StairCar::PMatrix.zeros(3,3)
+
+    matrix1.should == matrix2
+    matrix1.should_not == matrix3
+  end
+
+  it "should allow you to set with an array" do
+    matrix = StairCar::PMatrix.zeros(2,2)
+    matrix[nil,nil] = [[1,2],[3,4]]
+    matrix[0,0].should == 1.0
+    matrix[1,1].should == 4.0
+  end
+
+  it "should allow you to initialize by an array" do
+    matrix = StairCar::PMatrix.new([[1,2],[3,4]])
+    matrix[0,0].should == 1.0
+    matrix[1,1].should == 4.0
+  end
+
+  describe "dimensions" do
+    before(:all) do
+      @matrix = StairCar::PMatrix.zeros(3,2)
+    end
+    it "should return its shape" do
+      @matrix.shape.should == [3,2]
+    end
+
+    it "should return the rows" do
+      @matrix.rows.should == 3
+    end
+
+    it "should return the cols" do
+      @matrix.cols.should == 2
+    end
+  end
+end

data/spec/pmatrix/transforms_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'stair_car'
+
+describe StairCar::PMatrixTransforms do
+  it "should transpose" do
+    matrix = StairCar::PMatrix.asc(3,4)
+    (~matrix).should_not == matrix
+    (~~matrix).should == matrix
+  end
+
+  it 'should invert' do
+    matrix = StairCar::PMatrix.new([[4,3],[3,2]])
+    matrix.inv.should == StairCar::PMatrix.new([[-2, 3], [3, -4]])
+  end
+
+  it 'should raise an error when it fails to invert' do
+    matrix = StairCar::PMatrix.asc(3,3)
+    lambda {
+      matrix.inv
+    }.should raise_error(StairCar::InverseMatrixIsSignular)
+  end
+
+  it "should map and map_non_zero" do
+    matrix = StairCar::PMatrix.zeros(2,3)
+    matrix[0,0] = 5
+    matrix[1,2] = 10
+    mapped_matrix = matrix.map {|v| v * 2 }
+    mapped_matrix[0,0].should == 10
+    mapped_matrix[1,2].should == 20
+    mapped_matrix[0,1].should == 0
+
+    calls = 0
+    matrix.map_non_zero! {|v,row,col| calls += 1; v + 2 }
+    calls.should == 2
+    matrix[0,0].should == 7
+    matrix[1,2].should == 12
+  end
+
+  it "should convert back to a ruby array" do
+    matrix = StairCar::PMatrix.asc(3,3)
+    matrix.to_a.should == [[1,2,3],[4,5,6],[7,8,9]]
+  end
+
+end