stair_car 0.0.1

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.rvmrc
+.idea
+*.DS_Store
+lib/.DS_Store

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pmatrix.gemspec
+gemspec
+
+
+group :development do
+  gem 'guard'
+  gem 'rb-inotify', :require => false
+  gem 'rb-fsevent', :require => false
+  gem 'rb-fchange', :require => false
+  gem 'guard-rspec'
+  gem 'terminal-notifier-guard'
+end

data/Guardfile

@@ -0,0 +1,18 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  # watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # # Rails example
+  # watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  # watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  # watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  # watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  # watch('config/routes.rb')                           { "spec/routing" }
+  # watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Ryan Stout
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,223 @@
+# StairCar
+
+StairCar is a matlab or numpy like matrix library gem for jruby.  It provides several matrix classes that wrap different Java based matrix libraries in a simple ruby interface.  It overloads ruby operators to provide a matlab like functionality.
+
+# Goals
+
+StairCar should be:
+
+- Rubyish (object oriented, use operator overloading for math operations)
+- Fast (use optimized underlying storage/algebra systems, use BLAS where available)
+- Unified (It should provide a standard interface across multiple internal implementations)
+
+StairCar is geared towards two dimensional matrices and treats vectors as a 1 by M or N x 1 matrix.  StairCar currently does not support >2 dimensional matrices.  It also currently only supports double and float matrices.  Though support for integer and boolean matrices is planned.
+
+## Features
+
+- Dense and Sparse matrices (with 2^64 elements)
+- Ability to efficiently iterate on non-zero elements in sparse matrices
+- Subviews (that reference the original matrix)
+- Matrix, vector, and scalar add, sub, mul, div, and matrix multiply.  (In any combination)
+- Easy iteration on rows, cols, or elements
+- Element wise comparison >,>=,<,<= that returns a 1/0 matrix
+- Mathematical operations on the full matrix, rows, or cols (currently only std, variance, mean, max, min)
+- Shortcuts for making matricies (zeros, spzeros, rand, ones, asc, desc, etc...)
+- .dup to copy
+- == to compare values
+- A good clean inspect
+
+
+## Usage
+
+Once you have required stair_car, you will have access to two matrix classes (currently): PMatrix and UMatrix.  PMatrix wraps the pcolt library and is good for sparse matrices.  UMatrix wraps the ujmp library, which its self wraps many java libraries.  Currently UMatrix support is still a work in progress.
+
+### Basic Usage
+
+To start, include the StairCar module into your current class
+
+    include StairCar
+
+This provides you with many shortcut methods to make matricies:
+
+Dense: zeros, ones, rand, asc, desc
+Sparse: spzeros, spones, sprand, spasc, spdesc
+
+    m = asc(3,3)
+    => <#PMatrix(double) 3x3 dense>
+    1 2 3
+    4 5 6
+    7 8 9
+
+### Get elements
+
+You can get any element by passing in its row and column:
+
+    m[0,1]
+    => 2
+
+### Subviews
+
+StairCar supports many options to generate subviews.  You can pass in the following:
+
+- Arrays - Selects a row/column, treating the integer in the array as a row or column index.
+- Ranges - Selects each row/column index within the range
+- nil - Selects the whole row/column
+- You can also pass in a combination of arrays and ranges.
+
+For example:
+
+    m[0..1,nil]
+    => <#PMatrix() 2x3 dense>
+    1 2 3
+    4 5 6
+
+### Assignment
+
+You can assign a single element:
+
+    m[0,1] = 22.5
+
+    m
+    => <#PMatrix(double) 3x3 dense>
+    1    22.5 3
+    4    5    6
+    7    8    9
+
+You can assign a scalar to every value in a subview
+
+    # Assign a row (row 0, all columns)
+    m[0,nil] = 2
+
+    => <#PMatrix(double) 3x3 dense>
+    2 2 2
+    4 5 6
+    7 8 9
+
+You can assign an array or other matrix to a subview
+
+    # Assign an array to a row
+    m[0..1,nil] = [[1,2,3],[4,5,6]]
+
+    => <#PMatrix(double) 3x3 dense>
+    1 2 3
+    4 5 6
+    7 8 9
+
+    # Multiple row or column subviews
+    m[[1,2],2]
+    => <#PMatrix() 2x1 dense>
+    6
+    9
+
+### Math
+
+Math is simple, just use the standard +,-,/  * does matrix multiplication and ** does element wise multiplication.
+
+    a = asc(3,3)
+    b = asc(3,3)
+
+    a + b
+    => <#PMatrix(double) 3x3 dense>
+    2  4  6
+    8  10 12
+    14 16 18
+
+    a * b
+    => <#PMatrix(double) 3x3 dense>
+    30  36  42
+    66  81  96
+    102 126 150
+
+    a ** b
+    => <#PMatrix(double) 3x3 dense>
+    1  4  9
+    16 25 36
+    49 64 81
+
+### Transpose and inverse
+
+Transpose can be done with either matrix.transpose or ~matrix
+
+### Stats
+
+All stats operations can operate on the whole matrix, or just the columns or the rows.  Just pass in a dimension to specify cols or rows (rows = 0, cols = 1)
+
+    m = asc(3,3)
+    m.sum
+    => 45.0
+
+    m.sum(0)
+    => <#PMatrix(double) 1x3 dense>
+    12 15 18
+
+    m.sum(1)
+    => <#PMatrix(double) 3x1 dense>
+    6
+    15
+    24
+
+Supported operations
+
+- sum
+- max
+- min
+- mean
+- variance
+- std
+
+### Iteration
+
+Matrices support the standard ruby each, each_with_index, and map operations.  However each passes in a value, row, col instead of just a value.
+
+It also supports each_column and each_row
+
+You can also iterate or map on non-zero elements, which makes mapping sparse matrices much more efficient.  Use #each_non_zero, #map_non_zero, or #map_non_zero!  Using ! on the end of map or map_non_zero means all updates will happen to the original matrix, thus saving memory.
+
+    m = spzeros(5,5)
+    => <#PMatrix(double) 5x5 sparse>
+    0 0 0 0 0
+    0 0 0 0 0
+    0 0 0 0 0
+    0 0 0 0 0
+    0 0 0 0 0
+
+    m[0,2] = 5
+    m[3,4] = 10
+
+    m
+    => <#PMatrix(double) 5x5 sparse>
+    0  0  5  0  0
+    0  0  0  0  0
+    0  0  0  0  0
+    0  0  0  0  10
+    0  0  0  0  0
+
+    m.map_non_zero! {|value,row,col| value * 2 }
+    => <#PMatrix(double) 5x5 sparse>
+    0  0  10 0  0
+    0  0  0  0  0
+    0  0  0  0  0
+    0  0  0  0  20
+    0  0  0  0  0
+
+## Planned Features
+
+- JBLAS support
+- MRI support (perhaps with NMatrix)
+- More statistical features
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'stair_car'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install stair_car
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/stair_car/mmatrix/matlab_interface.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/../../matlab/matlabcontrol-4.0.0'
+class MatlabInterface
+  def initialize
+    factory = Java::Matlabcontrol::MatlabProxyFactory.new
+    @proxy = factory.proxy
+    @processor = Java::matlabcontrol.extensions.MatlabTypeConverter.new(@proxy)
+  end
+
+end

data/lib/stair_car/mmatrix/mmatrix.rb

@@ -0,0 +1,26 @@
+require 'stair_car/types'
+require 'stair_car/inspect'
+require 'stair_car/indicies'
+require 'stair_car/iteration'
+require 'stair_car/matrix_math'
+require 'stair_car/transforms'
+require 'stair_car/compare'
+
+class MMatrix
+  # include Types
+  # include Inspect
+  # include Indicies
+  # include Iteration
+  # include MatrixMath
+  # include Transforms
+  # include Compare
+
+  def initialize
+    @@mi ||= MatlabInterface.new
+  end
+
+  def [](rows, cols)
+
+
+  end
+end

data/lib/stair_car/pmatrix/compare.rb

@@ -0,0 +1,34 @@
+module StairCar
+  module PMatrixCompare
+    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.equals(matrix2.data)
+    end
+
+  end
+end

data/lib/stair_car/pmatrix/matrix_math.rb

@@ -0,0 +1,169 @@
+module StairCar
+  module PMatrixMatrixMath
+    class MatrixMathError < RuntimeError
+    end
+
+    def perform(val, &block)
+      result = @data.copy
+      if val.is_a?(PMatrix)
+        if rows == val.rows && cols == val.cols
+          # Another matrix of the same size
+          result = result.assign(val.data, &block)
+        elsif rows == val.rows && val.cols == 1
+          # Vector on column (vertical)
+          PMatrix.new(result).each_column do |row|
+            row.data.assign(val.data, &block)
+          end
+        elsif cols == val.cols && val.rows == 1
+          # Vector on rows (horizontal)
+          PMatrix.new(result).each_row do |col|
+            col.data.assign(val.data, &block)
+          end
+        else
+          # Incorrect size
+          raise MatrixMathError, "matrix dimensions incorrect"
+        end
+      else
+        # Passed in a number
+        perform_on_val = Proc.new do |cell_value|
+          yield(cell_value, val)
+        end
+
+        result.assign(perform_on_val)
+      end
+
+      return PMatrix.new(result)
+    end
+
+    def +(val)
+      perform(val) { |a,b| a + b }
+      # perform(val, Java::cern.jet.math.tdouble.DoubleFunctions.plus)
+    end
+
+    def -(val)
+      perform(val) { |a,b| a - b }
+    end
+
+    def **(val)
+      perform(val) { |a,b| a * b }
+    end
+
+    def /(val)
+      perform(val) { |a,b| a / b }
+    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 PMatrix.new(c)
+    end
+
+    def sum(dimension=nil)
+      if dimension == 0
+        # Sum rows
+        return PMatrix.ones(1, rows) * self
+      elsif dimension == 1
+        # Sum cols
+        return self * PMatrix.ones(cols, 1)
+      else
+        return @data.z_sum
+      end
+    end
+
+    def max(dimension=nil)
+      if dimension
+        value = aggrate_on_dimension(:max, dimension)
+      else
+        value, row, col = @data.max_location
+      end
+
+      return value
+    end
+
+    def min(dimension=nil)
+      if dimension
+        value = aggrate_on_dimension(:min, dimension)
+      else
+        value, row, col = @data.min_location
+      end
+
+      return value
+    end
+
+    def mean(dimension=nil)
+      if dimension
+        value = aggrate_on_dimension(:mean, dimension)
+      else
+        value = self.sum / self.size
+      end
+
+      return value
+    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 == 1
+          # Get the per row
+          vals = PMatrix.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 == 0
+          # Get the per row
+          vals = PMatrix.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