rmatrix 0.1.3 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2669d0b3df98c92b74abe27833d0a1d11f39bf84
-  data.tar.gz: e28379824f051e318780f7599bfe1d640dbb3bf1
+  metadata.gz: 3ef041f60282c09c58765f159e598b55a3cc7cd4
+  data.tar.gz: 624800e2934fe3858adfbbd62e6455574bce512b
 SHA512:
-  metadata.gz: adcd594922c431268a3f3734ee9e17055f29b05f3ede14bb1f9df17956bd19ce5f203ab78d5875caf5e1307d8b767fe3d9510545677673331c9d877297ea4471
-  data.tar.gz: 07642f99e0eca1b196fdee6889684f9271a3f0ea15d4e5c9edec8bb7e1cfd72a361547887b3b41b169be2d5b58da77d6443f718196be5e7e8b5787462dfe491b
+  metadata.gz: 1e8bf852ff5b4c8cad5e541b68604784a401ab140c01654f8bd442b4899c5b047de3d55dca050ab0e8452488f2fe56bd22cb0f40f7afa6620eb7277975ffffd2
+  data.tar.gz: 35fd9c5279d0b45c7a651c11ea06c9b42f26035697e0093a1b6cc32f95bb6dbb2a3b79ce6fd1f111d1fe0e0c6d3b0c5b316abba785500f298a8b42effdc030a4

data/lib/rmatrix.rb

@@ -1,3 +1,4 @@
 require_relative "rmatrix/version"
+require_relative "rmatrix/indices"
 require_relative "rmatrix/core"
 require_relative "rmatrix/shortcuts"

data/lib/rmatrix/indices.rb

@@ -0,0 +1,107 @@
+module RMatrix
+  module Indices
+    def [](*args)
+      indices           = unmap_args(args)
+      result_row_map    = build_result_map(self.row_map, indices.first, self.rows)      if self.row_map
+      result_column_map = build_result_map(self.column_map, indices.last, self.columns) if self.column_map
+      raw[*indices, column_map: result_column_map, row_map: result_row_map]
+    end
+
+    def raw
+      @raw ||= begin
+        raw = Struct.new(:narray, :typecode).new(self.narray, self.typecode)
+        def raw.[](*args, column_map: nil, row_map: nil)
+          args.all?{|x| Fixnum === x } ? narray[*args.reverse] : Matrix.new(narray[*args.reverse], typecode, column_map: column_map, row_map: row_map)
+        end
+        raw
+      end
+    end
+
+    def build_result_map(existing, indices, size)
+      return existing if indices == true
+      result_map = {}
+      indexify(indices, result_map, size)
+      result_map.default_proc =  ->(h,k) do
+        existing_index = existing[k]
+        case existing_index
+        when TrueClass
+          existing_index
+        when Range
+          if existing_index.exclude_end?
+            h[k] = h[existing_index.first]...h[existing_index.end]
+          else
+            h[k] = h[existing_index.first]..h[existing_index.end]
+          end
+        when nil
+          raise "Couldn't find key #{k} in index mapping"
+        else
+          h[existing_index]
+        end
+      end
+      result_map
+    end
+
+    def indexify(indices, results, size, total=0)
+      Array(indices).each do |index|
+        case index
+        when TrueClass
+          (0...size).each do |i|
+            results[i] = i
+          end
+        when Fixnum
+          results[index] ||= total
+          total += 1
+        when Array
+          indexify(index, results, size, total)
+        when Range
+          inclusive  = index.exclude_end? ? index.first..(index.end - 1) : index
+          flat_range = inclusive.end < inclusive.first ? [*inclusive.end..inclusive.first].reverse : [*inclusive]
+          flat_range.each do |elm|
+            indexify(elm, results, size, total)
+          end
+        end
+      end
+    end
+
+    def unmap_args(args)
+      if args.length == 1
+        if row_map
+          return [unmap_index(self.row_map, args[0]), true] rescue nil
+        end
+        if column_map
+          return [true, [unmap_index(self.column_map, args[0])]] rescue nil
+        end
+        return [args[0]]
+      else
+        [
+          self.row_map ? unmap_index(self.row_map, args[0]) : args[0],
+          Array(self.column_map ? unmap_index(self.column_map, args[1]) : args[1])
+        ]
+      end
+    end
+
+    def unmap_index(map, columns)
+      case columns
+      when TrueClass, FalseClass
+        columns
+      when Array
+        columns.map{|col| unmap_index(map, col)}.flatten
+      when Range
+        first = unmap_index(map, columns.first)
+        last = unmap_index(map, columns.end)
+        first = Range === first ? first.first : first
+        if columns.exclude_end?
+          last = Range === last ? last.first : last
+          first...last
+        else
+          last = Range === last ? last.end : last
+          first..last
+        end
+      else
+        index = map[columns]
+        raise "Value not present in index mapping: #{columns}" unless index
+        index
+      end
+    end
+  end
+end

data/lib/rmatrix/matrix.rb

@@ -2,21 +2,25 @@ module RMatrix
   class Matrix
     require 'narray'
     require_relative 'typecode'
+
     include Enumerable
+    include Indices
 
-    attr_accessor :invert_next_operation, :matrix, :narray, :typecode
+    attr_accessor :invert_next_operation, :narray, :typecode, :row_map, :column_map
+    attr_writer :matrix
 
-    def initialize(source, typecode=Typecode::FLOAT)
+    def initialize(source, typecode=Typecode::SFLOAT, column_map: nil, row_map: nil)
       self.typecode = typecode
       self.narray   = two_dimensional(source, typecode)
+      self.row_map, self.column_map = row_map, column_map
     end
 
     def matrix
-      @matrix ||= NMatrix.refer(narray)
+      @matrix ||= narray.empty? ? narray : NMatrix.refer(narray)
     end
 
-    def self.blank(rows, cols, typecode=Typecode::FLOAT)
-      self.new(NArray.new(typecode, rows * cols).reshape(cols, rows), typecode)
+    def self.blank(rows: 1, columns: 1, typecode: Typecode::SFLOAT, initial: 0)
+      self.new(NArray.new(typecode, columns, rows), typecode) + initial
     end
 
     def _dump(level)
@@ -37,6 +41,24 @@ module RMatrix
       block_given? ? e.each(&block) : e
     end
 
+    def each_column(&block)
+      e = Enumerator.new do |enum|
+        (0...self.columns).each  do |i|
+          enum << self.raw[true, i]
+        end
+      end
+      block_given? ? e.each(&block) : e
+    end
+
+    def each_row(&block)
+     e = Enumerator.new do |enum|
+        (0...self.rows).each  do |i|
+          enum << self.raw[i, true]
+        end
+      end
+      block_given? ? e.each(&block) : e
+    end
+
     def mmap
       as_na = NArray.to_na(
         matrix.each.map do |elm|
@@ -46,13 +68,23 @@ module RMatrix
       Matrix.new(as_na.reshape(*shape), typecode)
     end
 
+    def mask
+      mmap do |elm|
+        (yield elm) ? 0 : elm
+      end
+    end
+
+    def abs
+      (self ** 2) ** 0.5
+    end
+
     def coerce(other)
       self.invert_next_operation = true
       [self, other]
     end
 
     def size
-      self.shape.inject(:*)
+      self.shape.inject(:*).to_i
     end
 
     def rows
@@ -63,12 +95,68 @@ module RMatrix
       self.shape.first
     end
 
+    def diag(dim=0)
+      raise "Must be square matrix" unless self.shape[0] == self.shape[1]
+      Matrix.new((self.class.identity(self.shape[0]).mult self).sum(dim))
+    end
+
+    def self.identity(size)
+      blank = self.blank(rows: size, columns: size)
+      blank.diagonal(1)
+    end
+
     def sum_rows
-      Matrix.new(sum(0), typecode)
+      sum(1)
     end
 
     def sum_columns
-      Matrix.new(sum(1), typecode)
+      sum(0)
+    end
+
+    def concat(*others, rows: true)
+      others.map!{|o| Matrix === o ? o.narray : NArray.to_na(o)}
+
+      joined = case rows
+      when true
+        # raise "Rows must match #{self.rows}, #{others.map(&:rows)}" unless [self.rows, *others.map(&:shape).map(&:last)].uniq.count.one?
+        height = self.rows + others.map(&:shape).map(&:last).inject(:+)
+        width  = others[0].shape.first
+        joined = ::NArray.new(typecode, width, height)
+        joined[true, 0...self.rows] = self.narray
+        current_row = self.rows
+        others.each do |slice|
+          slice_height = slice.shape[1]
+          joined[true, current_row...current_row+slice_height] = slice
+          current_row += slice_height
+        end
+        joined
+      else
+        width  = self.columns + others.map(&:shape).map(&:first).inject(:+)
+        height = others[0].shape.last
+        joined = ::NArray.new(typecode, width, height)
+        joined[0...self.columns, true] = self.narray
+        current_col = self.columns
+        others.each do |slice|
+          slice_width = slice.shape[0]
+          joined[current_col...current_col+slice_width, true] = slice
+          current_col += slice_width
+        end
+        joined
+        # raise "Rows must match #{self.columns}, #{others.map(&:columns)}" unless [self.columns, *others.map(&:columns)].uniq.count.one?
+      end
+
+      Matrix.new(joined, typecode)
+    end
+
+    def join(other)
+      case true
+      when self.rows == 1 && other.rows == 1
+        Vector.new(NArray.to_na([self.narray,other.narray]).to_type(self.typecode).reshape(self.columns + other.columns, 1))
+      when self.columns == 1 && other.columns == 1
+        Vector.new(NArray.to_na([self.narray,other.narray]).to_type(self.typecode).reshape(1, self.rows + other.rows))
+      else
+        raise "Couldn't join mismatched dimensions"
+      end
     end
 
     def two_dimensional(source, type)
@@ -82,6 +170,12 @@ module RMatrix
         source = NArray.to_na([source])
       else
         source = NArray.to_na(source)
+        if type != RMatrix::Matrix::Typecode::OBJECT &&
+          source.typecode == RMatrix::Matrix::Typecode::OBJECT &&
+          RMatrix::Matrix === source[0]
+          source = NArray.to_na(source.map(&:to_a).to_a).to_type(typecode)
+        end
+        source
       end
 
       source = source.to_type(type) unless type == source.typecode
@@ -89,7 +183,7 @@ module RMatrix
       case source.dim
       when 1
         source.reshape(source.length, 1)
-      when 2
+      when 2, 0
         source
       else
         raise "Source for matrix must be either one or two dimensional" unless source.shape[2..-1].all?{|x| x == 1}
@@ -116,11 +210,11 @@ module RMatrix
 
     def determinant
       raise "Cannot calculate determinant of non-square matrix" unless columns == rows
-      return self[0, 0] * self[1, 1]- self[0, 1] * self[1, 0] if(self.columns == 2)
+      return self.raw[0, 0] * self.raw[1, 1]- self.raw[0, 1] * self.raw[1, 0] if(self.columns == 2)
       sign = 1
       det = 0
       self.columns.times do |i|
-        det += sign * self[0,i] * self.minor(0, i).determinant
+        det += sign * self.raw[0,i] * self.minor(0, i).determinant
         sign *= -1
       end
       return det
@@ -159,9 +253,13 @@ module RMatrix
       mmap{|x| x.round(dp) }
     end
 
-    def inspect
-      return Vector::inspect_vector(self) if [rows, columns].include?(1)
+    def is_vector?
+      [rows, columns].include?(1)
+    end
 
+    def inspect
+      return 'M[Empty]' if empty?
+      return Vector::inspect_vector(self) if self.is_vector?
       inspect_rows    = [10, self.rows].min
       inspect_columns = [10, self.columns].min
       more_rows       = inspect_rows    < self.rows
@@ -176,29 +274,28 @@ module RMatrix
       "#{rows} x #{columns} Matrix\nM#{box_lines(as_strings.map{|row| row.join(", ") }, more_columns)}"
     end
 
-
-    def [](*args)
-      args.all?{|x| Fixnum === x } ? narray[*args.reverse] : Matrix.new(narray[*args.reverse], typecode)
-    end
-
     def transpose
       Matrix.new(self.matrix.transpose, typecode)
     end
 
-    def self.[](*inputs)
+    def self.[](*inputs, typecode: Typecode::SFLOAT, row_map: nil, column_map: nil)
       if inputs.length == 1 && Matrix === inputs[0]
         inputs[0]
       elsif inputs.length == 1 && [String, Symbol].include?(inputs[0].class)
         if ['byte', 'sint', 'int', 'sfloat', 'float', 'scomplex', 'complex', 'object'].include?(inputs[0])
-          ->(*source){ Matrix.new(source, inputs[0]) }
+          ->(*source){ Matrix.new(source, inputs[0], row_map: row_map, column_map: column_map)}
         else
-          Matrix.new(inputs[0])
+          Matrix.new(inputs[0], typecode, row_map: row_map, column_map: column_map)
         end
       else
-        Matrix.new(inputs)
+        Matrix.new(inputs, typecode, row_map: row_map, column_map: column_map)
       end
     end
 
+    def zip(*others)
+      Matrix.new(super(*others), self.typecode)
+    end
+
     def self.gen_mutator(name)
       define_method(name) do |*args, &blk|
         matrix.send(name, *args, &blk)
@@ -212,9 +309,22 @@ module RMatrix
       end
     end
 
+    def sum(dim=nil)
+      case dim
+      when nil then
+        res = self.narray.sum
+        NArray === res ? Matrix.new(0, typecode)[0] : res
+      else Matrix.new(self.matrix.sum(dim), typecode)
+      end
+    end
+
     def self.gen_delegator(name)
       define_method(name) do |*args, &blk|
-        matrix.send(name, *args, &blk)
+        result = matrix.send(name, *args, &blk)
+        case result
+        when NArray then Matrix.new(result, typecode)
+        else result
+        end
       end
     end
 
@@ -234,13 +344,12 @@ module RMatrix
     end
 
     [:fill!, :random!, :indgen!].each(&method(:gen_mutator))
-    [:reshape, :sort, :sort_index, :inverse, :lu, :delete_at, :where, :where2, :not, :-@].each(&method(:gen_matrix_delegator))
-    [:sum, :prod, :mean, :stddev, :rms, :rmsdev, :min, :max, :shape, :to_a].each(&method(:gen_delegator))
+    [:reshape, :sort, :sort_index, :inverse, :lu, :delete_at, :where, :where2, :not, :-@, :reverse, :diagonal].each(&method(:gen_matrix_delegator))
+    [:prod, :min, :max, :stddev, :mean, :rms, :rmsdev, :shape, :empty?].each(&method(:gen_delegator))
     [:byte, :sint, :int, :sfloat, :float, :scomplex, :complex, :object].each(&method(:gen_typeconstructor))
-
-    [:+, :/, :-, :**, :&, :^, :|].each do |op|
-      op = translate_op(op)
-      define_method(op) do |other|
+    [:+, :/, :-, :**, :&, :^, :|].each do |_op|
+      op = translate_op(_op)
+      define_method(_op) do |other|
         result = case other
         when Matrix
           apply_elementwise(op, other)
@@ -253,10 +362,23 @@ module RMatrix
       end
     end
 
+    def to_a
+      return narray.reshape(narray.length).to_a if is_vector?
+      return narray.to_a
+    end
+
     def self.seed(seed)
       NArray.srand(seed)
     end
 
+    def to_m
+      self
+    end
+
+    alias_method :cols, :columns
+    alias_method :avg, :mean
+    alias_method :length, :size
+
     private
       def test_inverse
         if self.invert_next_operation
@@ -287,6 +409,7 @@ module RMatrix
         end
       end
 
+
   end
 
   class ::NArray; include Enumerable; end

data/lib/rmatrix/vector.rb

@@ -14,7 +14,7 @@ module RMatrix
     def self.[](*inputs)
       if inputs.length == 1 && [String, Symbol].include?(inputs[0].class)
         if ['byte', 'sint', 'int', 'sfloat', 'float', 'scomplex', 'complex', 'object'].include?(inputs[0].to_s)
-          ->(*source){ Matrix.new(source, typecode: inputs[0].to_s) }
+          ->(*source){ Matrix.new(source, inputs[0].to_s) }
         else
           Vector.new(inputs[0])
         end

data/lib/rmatrix/version.rb

@@ -1,3 +1,3 @@
 module Rmatrix
-  VERSION = "0.1.3"
+  VERSION = "0.1.7"
 end

data/rmatrix.gemspec

@@ -35,4 +35,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "pry"
   spec.add_development_dependency "pry-byebug"
   spec.add_runtime_dependency "narray"
+  spec.add_runtime_dependency "opencl_ruby_ffi"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rmatrix
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.7
 platform: ruby
 authors:
 - Wouter Coppieters
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-04-11 00:00:00.000000000 Z
+date: 2016-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: opencl_ruby_ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |-
   RMatrix is a lightning fast library for Ruby. It provides numerous enhancements over the Matrix class in the standard library.
     Features include the ability to calculate Matrix inverse, transpose, determinant, minor, adjoint, cofactor_matrix, hadamard product and other elementwise operations, slicing, masking and more.
@@ -114,6 +128,7 @@ files:
 - bin/setup
 - lib/rmatrix.rb
 - lib/rmatrix/core.rb
+- lib/rmatrix/indices.rb
 - lib/rmatrix/matrix.rb
 - lib/rmatrix/shortcuts.rb
 - lib/rmatrix/typecode.rb
@@ -141,9 +156,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Fast matrix/linear algebra library for Ruby
 test_files: []
-has_rdoc: