matrix_gem 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dead9ede19c10d0e07aab6515af1c7b9beb37a03
+  data.tar.gz: 8982a7fb48c26c4ce88891d3c6308fd0d265b05a
+SHA512:
+  metadata.gz: 2b5630df3882796c82788bdcb787938a6a121d2222ee81228deba8494bcda0267d380bc1aa662d31b5905a49d95147a975c5864107ed84767e075273e1b90d4a
+  data.tar.gz: f956702d425022d394d4597437bcf6ddc2f53e375261c4b3eb91415b6f0daf4f7ccfdace759660e24cabbe916b7d780c73704d2212d4baf58f63968e36f5eb89

data/lib/matrix_gem/matrix_err.rb

@@ -0,0 +1,33 @@
+module MatrixErr
+
+  class Matrix_Error < StandardError
+  end
+
+  class MatrixArgumentError < Matrix_Error
+  end
+
+  class ErrOperationNotDefine < Matrix_Error
+    def message
+      "Operation is not define!"
+    end
+  end
+
+  class ErrDimensionMismatch < Matrix_Error
+    def message
+      "Matrices dimensions mismatch!"
+    end
+  end
+
+  class NoSquareMatrix < Matrix_Error
+    def message
+      "Matrix should be squared!"
+    end
+  end
+
+  class ErrZeroDeterminant < Matrix_Error
+    def message
+      "Matrix determinant should be not equal to zero!"
+    end
+  end
+
+end

data/lib/matrix_gem/properties_module.rb

@@ -0,0 +1,47 @@
+module Properties
+  # Returns an array of arrays that describe the rows of the matrix.
+  def to_a
+    self
+  end
+
+  # Returns the number of columns.
+  # Also aliased as n(), col_size(), column_count()
+  def col_length
+    self[0].length
+  end
+
+  # Returns the number of rows.
+  # Also aliased as m(), row_size(), row_count()
+  def row_length
+    i = 0
+    self.each{ |row| i+=1 }
+    i/self[0].length
+  end
+
+  alias m row_length
+  alias row_size row_length
+  alias row_count m
+
+
+  alias n col_length
+  alias col_size col_length
+  alias column_count n
+
+  # Retun row on index.
+  def row(index)
+    self[index]
+  end
+
+  # Set value of matrix row.
+  def row_change(index, elements)
+    self[index] = elements
+  end
+
+  # Return col on index
+  # Also aliased as column()
+  def col(index)
+    self.each { |a| p a[index] }
+  end
+
+  alias column col
+end

data/lib/matrix_gem.rb

@@ -0,0 +1,305 @@
+require 'matrix_gem/matrix_err'
+require 'matrix_gem/properties_module'
+
+
+  class Matrix
+    include MatrixErr
+    include Properties
+    include Enumerable
+
+    #---------Initialize the matrix------
+    #  1. Matrix with values
+    #     Matrix.new(rows, cols, numbers) // numbers = rows*cols
+    #  2. Matrix only with dimention(rows and cols) make Identity matrix
+    #     Matrix.new(rows, cols)
+    def initialize(rows, cols, *nums)
+      if rows < 1 || cols < 1
+        raise MatrixArgumentError, "Rows and Columns should be positive numbers!"
+      elsif nums.length == 0
+        @matrix = identity cols
+      elsif rows * cols == nums.length
+        @matrix = matrix_with_values nums, cols
+      else
+        raise MatrixArgumentError,
+        "Wrong number of arguments (#{2 + nums.length} for #{2 + rows * cols})"
+      end
+      @matrix
+    end
+
+    #Return the sum of two matrices in new matrix
+    def +(matrix)
+      sum_validation(matrix, self)
+      values = self.zip(matrix).map{|i| i.inject(:+)}
+
+      Matrix.new self.m, self.n, *(values)
+    end
+
+    #Return the difference of two matrices in new matrix
+    def -(matrix)
+      sum_validation(matrix, self)
+      values = self.zip(matrix).map{|i| i.inject(:-)}
+
+      Matrix.new self.m, self.n, *(values)
+    end
+
+    # Returns element (i,j) of the matrix. That is: row i, column j.
+    # If only i is given return row[i]. That is: row with index i.
+    def [](i, j = nil)
+      if j == nil
+        @matrix[i]
+      else
+        @matrix[i][j]
+      end
+    end
+
+    # Set element (i,j) of the matrix. That is: row i, column j.
+    # Set row i of the matrix if j is not given. That is: column j.
+    # Also aliased as set_element
+    def []=(i, j = nil, val)
+      if j == nil
+        raise ErrDimensionMismatch if val.length != self.m
+        @matrix[i] = val
+      else
+        @matrix[i][j] = val
+      end
+    end
+    alias set_element []=
+
+    # Return a new matrix which is the transposition of the given one.
+    def transposed
+      elements = []
+      @matrix.to_a.transpose.map{ |x| x.map{ |y| elements << y } }
+      Matrix.new self.m, self.n, *(elements)
+    end
+
+    # Transpose the matrix.
+    # Also aliased as t().
+    def transpose
+      elements = []
+      @matrix.to_a.transpose.map{ |x| x.map{ |y| elements << y } }
+      @matrix = elements.each_slice(@matrix[0].length).to_a
+    end
+    alias t transpose
+
+    #Each method.
+    def each
+      @matrix.each  do |sub_arr|
+        sub_arr.each do |value|
+          yield value
+        end
+      end
+    end
+
+    # Returns true if and only if the two matrices contain equal elements.
+    def ==(matrix)
+      matrix.to_a == self.to_a
+    end
+
+    # Matrix multiplication.
+    def *(m)
+      case(m)
+      when Numeric
+        new_matrix_values = []
+        self.each { |x| new_matrix_values << x * m }
+        Matrix.new self.m, self.n, *(new_matrix_values)
+      when Matrix
+        multiply_validation self, m
+        rows = Array.new(self.m) { |i|
+          Array.new(m.n) { |j|
+            (0 ... m.n ).inject(0)  do |vij, k|
+              vij + self[i, k] * m[k, j]
+            end
+          }
+        }
+      end
+    end
+
+    # Returns the determinant of the matrix.
+    # Also alised as determinant()
+    def det
+      is_square_validation self
+
+      _this = copy(self)
+      c = 1
+      new_matrix = nil
+      size = _this.n
+
+      (0..size - 2).each do |i|
+        (i + 1..size -1).each do |j|
+          if _this[i][i] == 0
+            (i+1..size-1).each do |k|
+              if _this[k,i] != 0
+                swap_rows(_this, k, i)
+                c *= -1
+              end
+            end
+          end
+          if _this[i,i] == 0
+            p _this
+            return 0
+          end
+
+          new_matrix = cauchy_method(_this, i, j, -_this[j,i]/_this[i,i].to_f)
+        end
+      end
+
+      det = 1
+
+      (0..size-1).each do |i|
+        det *= new_matrix[i][i]
+      end
+
+      det *= c
+      det.round
+    end
+    alias determinant det
+
+    # Multiplication of matrix row with number.
+    def multiply_row(matrix, index, number)
+      matrix = matrix.row(index).map{ |n| n*number }
+    end
+
+    # Returns the inverse of the matrix.
+    def inverse
+      is_square_validation self
+      raise ErrZeroDeterminant if self.det == 0
+
+      _this = copy(self)
+      c = 1
+      e = Matrix.new _this.m, _this.n
+      size = _this.m
+
+      (0..size-2).each do |i|
+        (i+1..size-1).each do |j|
+          if _this[i, i] == 0
+            (i..size-2).each do |k|
+              if _this[k, i] != 0
+                swap_rows(_this, k, i)
+                swap_rows(e, k, i)
+                c *= -1
+              end
+            end
+          end
+
+          return 0 if _this[i, i] == 0
+
+          cauchy_method(e, i, j, -_this[j, i]/_this[i, i].to_f)
+          cauchy_method(_this, i, j, -_this[j, i]/_this[i, i].to_f)
+        end
+      end
+
+      (0..size-2).each do |i|
+        (i+1..size-1).each do |j|
+
+          cauchy_method(e, size-i-1, size-j-1, -_this[size-j-1, size-i-1]/_this[size-i-1, size-i-1])
+
+          cauchy_method(_this, size-i-1, size-j-1, -_this[size-j-1, size-i-1]/_this[size-i-1, size-i-1])
+        end
+      end
+
+      (0..size-1).each do |i|
+        e.row_change i, multiply_row(e, i, 1/_this[i,i])
+        _this.row_change i, multiply_row(_this, i, 1/_this[i,i])
+      end
+      e
+    end
+
+    # Chanege matrix to its inversed.
+    def inversed
+      elements = []
+      self.inverse.each{ |x| elements << x}
+      @matrix = elements.each_slice(@matrix[0].length).to_a
+    end
+
+    # def to_s
+    #   "Matrix[" + @matrix.map{|row|
+    #   "[" + row.map{|e| e.to_s}.join("\t") + "]"
+    #   }.join(", ") + "]"
+    # end
+
+    private
+
+    # Swap to matrix rows.
+    def swap_rows(_this, row1_index, row2_index)
+      _this[row1_index], _this[row2_index] = _this[row2_index], _this[row1_index]
+    end
+
+    # Return new instance of Matrix with same values.
+    def copy(_this)
+      values = []
+      _this.each{ |row| values << row }
+      copy = Matrix.new _this.m, _this.n, *(values)
+    end
+
+    # Multiply the first row elements with multiplier and sum it with second row
+    # elements.
+    # Used to make matrix in triangular form.
+    def cauchy_method(_this, row1_index, row2_index, multiplier)
+      _this.row(row2_index).each_with_index do |row_element, i|
+        _this.row(row2_index)[i] += _this[row1_index][i] * multiplier
+      end
+      _this
+    end
+
+    # Check if caller matrix columns are equal to other matrix rows.
+    def multiply_validation(_this, matrix)
+      raise ErrDimensionMismatch if _this.n != matrix.m
+    end
+
+    # Check if matrix rows are equals to its columns.
+    def is_square_validation(_this)
+      raise NoSquareMatrix if _this.m != _this.n
+    end
+
+    # Check if matrices have same dimentions.
+    def sum_validation(_this, matrix)
+      raise ErrOperationNotDefine if matrix.is_a? Numeric
+      raise ErrDimensionMismatch if matrix.m != _this.m || matrix.n != _this.n
+    end
+
+    # Make Identity matrix.
+    def identity(dimension)
+      id_matrix = []
+      dimension.times do |x|
+        id_matrix[x] = []
+        dimension.times do |y|
+          if x == y
+            id_matrix[x][y] = 1
+          else
+            id_matrix[x][y] = 0
+          end
+        end
+      end
+      return id_matrix
+    end
+
+    # Format values.
+    def matrix_with_values(values, col_length)
+      matrixNums = values.each_slice(col_length).to_a
+    end
+  end
+
+
+a = Matrix.new 3,3,1,2,57,1,3,43,5,6,70
+# p a
+c = Matrix.new 2,2,4,3,3,2
+d = Matrix.new 3,3,2,3,1,1,2,1,3,5,3
+# d = Matrix.new 2,2,0,1,3,0
+# d = Matrix.new 2,2,0,9,5,2
+
+
+d = Matrix.new 3,3
+
+#
+
+
+
+
+
+
+
+
+
+
+
+

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: matrix_gem
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Bozhidar Grigorov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-11 00:00:00.000000000 Z
+dependencies: []
+description: Gem for work with matrices
+email: bojko002@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/matrix_gem.rb
+- lib/matrix_gem/matrix_err.rb
+- lib/matrix_gem/properties_module.rb
+homepage: http://rubygems.org/gems/matrix_gem
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: Matrix gem
+test_files: []