matrix_gem 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dead9ede19c10d0e07aab6515af1c7b9beb37a03
-  data.tar.gz: 8982a7fb48c26c4ce88891d3c6308fd0d265b05a
+  metadata.gz: bc7ba70b852af0c334f8206cd216b1ff2dbf4d33
+  data.tar.gz: 8ce5d4a3281b74f3920886c427c6d9a22791fea4
 SHA512:
-  metadata.gz: 2b5630df3882796c82788bdcb787938a6a121d2222ee81228deba8494bcda0267d380bc1aa662d31b5905a49d95147a975c5864107ed84767e075273e1b90d4a
-  data.tar.gz: f956702d425022d394d4597437bcf6ddc2f53e375261c4b3eb91415b6f0daf4f7ccfdace759660e24cabbe916b7d780c73704d2212d4baf58f63968e36f5eb89
+  metadata.gz: bc66b52f0908a2c87e4e15492cddd2ddc3648bbd2bee0907785a2c2730d0bca7b429e7eefef20ee901dcdd90d109a5e2d7df7244cb805237f6e6ec1b35a2921e
+  data.tar.gz: 0071e0d34d392db460c59645dd49f7b23b6ed6e556f78258ee3d1403d126ad8562b9a53e50f1e869b9d51f761badc1698a74badf9d0b852b462761947f6adb32

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler"
+Bundler::GemHelper.install_tasks
+Bundler.setup
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/lib/matrix_gem/diagonal_matrix.rb

@@ -0,0 +1,109 @@
+
+
+  class Diagonal_Matrix < Matrix
+
+    # Creates a matrix by given rows, columns, and nums where the diagonal elements are composed of nums.
+    # With given only rows create identity matrix.
+    def initialize(rows, cols = nil, *nums)
+      if cols == nil
+        @matrix = identity rows
+      elsif nums.length != [rows, cols].min
+        raise MatrixArgumentError,
+        "Wrong number of arguments (#{2 + nums.length} for #{2 + [rows, cols].min})"
+      else
+        @matrix = []
+        rows.times do |row|
+          @matrix[row] = []
+          cols.times do |col|
+            if row == col
+              @matrix[row][col] = nums[row]
+            else
+              @matrix[row][col] = 0
+            end
+          end
+        end
+      end
+    end
+
+    class << self
+      # Creates a matrix where the diagonal elements are composed of nums.
+      def diagonal(*nums)
+        size = nums.length
+        Diagonal_Matrix.new size, size, *(nums)
+      end
+
+      # Creates a zero matrix with dimension equal to n.
+      def zero(n)
+        Diagonal_Matrix.diagonal(*(Array.new(n, 0)))
+      end
+
+      def identity(n)
+        Diagonal_Matrix.new n
+      end
+    end
+
+    # Set element on main diagonal
+    def []=(i, j = nil, value)
+      if j != nil && i != j
+        raise MatrixIndexOutOfRange,
+        "You can set only elements on main diagonal in a diagonal matrix."
+      elsif @matrix.size <= i
+        raise MatrixIndexOutOfRange
+      end
+        @matrix[i][i] = value
+    end
+
+    # Sum values on main diagonal of two matrices.
+    # Raises error if 'matrix' is not a Matrix or if matrices dimensions mismatch.
+    def +(matrix)
+      sum_validation(self, matrix)
+      values = self.diagonal_values.zip(matrix.diagonal_values).map{ |i| i.inject(:+) }
+      Diagonal_Matrix.new self.m, self.n, *(values)
+    end
+
+    # Returns the difference of values on main diagonal of two matrices in new matrix.
+    # Raises error if 'matrix' is not a Matrix or if matrices dimensions mismatch.
+    def -(matrix)
+      sum_validation(self, matrix)
+      values = self.diagonal_values.zip(matrix.diagonal_values).map{ |i| i.inject(:-) }
+
+      Diagonal_Matrix.new self.m, self.n, *(values)
+    end
+
+    # Matrix multiplication. Returns new instance of Diagonal_Matrix.
+    # Raises error if product can't be instance of Diagonal_Matrix.
+    def *(matrix)
+      product = super(matrix)
+      raise MatrixInvalidValue, "Product of multiplication is not diagonal matrix." if product.diagonal?
+
+      Diagonal_Matrix.new(product.m, product.n, *(product.diagonal_values))
+    end
+
+    # Matrix division (multiplication by the inverse).
+    # Raises error if difference can't be instance of Diagonal_Matrix.
+    # Raises error if matrix is not invertible.
+    def /(matrix)
+      diff = super(matrix)
+      raise MatrixInvalidValue, "Difference of matrices in not a diagonal matrix." if diff.diagonal?
+
+      Diagonal_Matrix.new(diff.m, diff.n, *(diff.diagonal_values))
+    end
+
+    # Returns the determinant of the matrix.
+    def det
+      is_square_validation self
+      self.diagonal_values.reduce(:*)
+    end
+
+    private
+
+    def non_main_diagonal_elements?(matrix)
+      matrix.m.times do |i|
+        matrix.n.times do |j|
+          return true if ((i != j) && (matrix[i,j] != 0))
+        end
+      end
+      false
+    end
+  end
+

data/lib/matrix_gem/matrix.rb

@@ -0,0 +1,371 @@
+  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 dimension(rows and cols) make Identity matrix with dimension
+    #     equal to rows
+    #     Matrix.new(rows, cols)
+    def initialize(rows, cols, *nums)
+      if rows < 1 || cols < 1
+        raise MatrixArgumentError, "Rows and Columns should be positive numbers!"
+      elsif ((cols.is_a? Float) || (rows.is_a? Float))
+        raise MatrixArgumentError, "Dimension of matrix can't be floating point number"
+      elsif nums.length == 0
+        @matrix = identity rows
+      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
+
+    class << self
+
+      # Creates an n by n zero matrix.
+      def zero(n)
+        values = Array.new(n*n, 0)
+        Matrix.new n, n, *(values)
+      end
+
+      # Creates a matrix where the diagonal elements are composed of values.
+      def diagonal(*nums)
+        raise ArgumentError, "Matrix values can't be nil" if nums.include? nil
+        size = nums.length
+        matrix_values = []
+        Array.new(size) { |i| Array.new(size) do |j|
+          if i == j
+            matrix_values << nums[i]
+          else
+            matrix_values << 0
+          end
+       end
+          }
+        Matrix.new(size, size, *(matrix_values))
+      end
+
+      # Creates an n by n identity matrix.
+      def identity(n)
+        Matrix.new n, n
+      end
+    end
+
+    # Return the sum of two matrices in new matrix
+    # Raises an error if matrices dimension mismatch.
+    def +(matrix)
+      sum_validation(self, matrix)
+      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.
+    # Raises an error if matrices dimension mismatch.
+    def -(matrix)
+      sum_validation(self, matrix)
+      values = self.zip(matrix).map{|i| i.inject(:-)}
+
+      Matrix.new self.m, self.n, *(values)
+    end
+
+    # Matrix multiplication.
+    def *(matrix)
+      case(matrix)
+      when Numeric
+        new_matrix_values = []
+        self.each { |x| new_matrix_values << x * matrix }
+        Matrix.new self.m, self.n, *(new_matrix_values)
+      when Matrix
+        multiply_validation self, matrix
+        rows = Array.new(self.m) { |i|
+          Array.new(matrix.n) { |j|
+            (0 ... self.n).inject(0) do |vij, k|
+              vij + self[i, k] * matrix[k, j]
+            end
+          }
+        }
+        values = []
+        rows.each{ |x| x.each { |y| values << y} }
+        Matrix.new self.m, matrix.n, *(values)
+      end
+    end
+
+    # Matrix division (multiplication by the inverse).
+    def /(matrix)
+      case matrix
+      when Numeric
+        new_matrix_values = []
+        self.each { |x| new_matrix_values << x / matrix.to_f }
+        Matrix.new self.m, self.n, *(new_matrix_values)
+      when Matrix
+        self * matrix.inversed
+      end
+    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
+      elsif (i < self.m && j < self.n)
+        @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
+      self
+    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)
+      (0..self.m-1).each do |i|
+        (0..self.n-1).each do |j|
+          return false if self[i][j] != matrix[i][j]
+        end
+      end
+      true
+    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
+            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
+
+    # Returns new matrix witch is the inverse of the matrix.
+    def inversed
+      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.set_row i, multiply_row(e, i, 1/_this[i,i])
+        _this.set_row i, multiply_row(_this, i, 1/_this[i,i])
+      end
+        Matrix.new self.m, self.m, *(e)
+      end
+
+    # Chanege matrix to its inversed.
+    def inverse
+      elements = []
+      self.inversed.each{ |x| elements << x}
+      @matrix = elements.each_slice(@matrix[0].length).to_a
+      self
+    end
+
+    # To stirng method.
+    def to_str
+      a = "Matrix\n" + @matrix.map do |row|
+        "[" + row.map do |e|
+           e.to_s
+        end.join(" ") + "]"
+      end.join(",\n")
+      puts a
+    end
+
+    # Matrix exponentiation. Equivalent to multiplying the matrix by itself N times.
+    def **(n)
+      raise MatrixArgumentError if !(n.is_a? Integer)
+      matrix = Matrix.identity(self.m)
+      n.times { |_| matrix *= self } if self.square?
+      matrix
+    end
+
+    def minor(*param)
+      row_range, col_range = param
+
+      from_row = row_range.first
+      form_row += self.m if from_row < 0
+      to_row = row_range.end
+      to_row += self.m if to_row < 0
+      to_row += 1 unless row_range.exclude_end?
+      size_row = to_row - from_row
+
+      from_col = col_range.first
+      from_col += self.n if from_col < 0
+      to_col = col_range.end
+      to_col += self.n if from_col < 0
+      to_col += 1 unless col_range.exclude_end?
+      size_col = to_col - from_col
+      return nil if from_row > row_count || from_col > column_count ||
+        from_row < 0 || from_col < 0
+        rows = @matrix[from_row, size_row].collect{ |row| row[from_col, size_col] }
+        values = []
+        rows.each{ |row| row.each {|val| values << val } }
+        Matrix.new [self.m - from_row, size_row].min, [self.n - from_col, size_col].min, *(values)
+    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.col_size != matrix.row_size
+    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 dimensions.
+    def sum_validation(_this, matrix)
+      raise ErrOperationNotDefine if !matrix.is_a? Matrix
+      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
+
+    # Multiplication of matrix row with number.
+    def multiply_row(matrix, index, number)
+      matrix = matrix.row(index).map{ |n| n * number }
+    end
+
+    # Format values.
+    def matrix_with_values(values, col_length)
+      matrixNums = values.each_slice(col_length).to_a
+    end
+
+  end
+
+

data/lib/matrix_gem/matrix_err.rb

@@ -3,9 +3,15 @@ module MatrixErr
   class Matrix_Error < StandardError
   end
 
+  class MatrixInvalidValue < StandardError
+  end
+
   class MatrixArgumentError < Matrix_Error
   end
 
+  class MatrixIndexOutOfRange < Matrix_Error
+  end
+
   class ErrOperationNotDefine < Matrix_Error
     def message
       "Operation is not define!"
@@ -29,5 +35,4 @@ module MatrixErr
       "Matrix determinant should be not equal to zero!"
     end
   end
-
 end

data/lib/matrix_gem/orthogonal_matrix.rb

@@ -0,0 +1,26 @@
+  class Orthogonal_Matrix < Matrix
+
+  # Initialize orthogonal matrix (square matrix and its transpose is equal to its inverse).
+    def initialize(rows, cols, *nums)
+      if !(Matrix.new rows, cols, *(nums)).orthogonal?
+        raise MatrixArgumentError,
+        "Can't initialize orthogonal matrix with this values."
+      elsif nums.length == 0
+          @matrix = identity rows
+      else
+        @matrix = matrix_with_values nums, cols
+      end
+    end
+
+    # Set element.
+    # Raise error if the matrix with new value is not orthogonal.
+    def []=(i, j, value)
+      b = copy(self)
+      b[i,j] = value
+      if b.orthogonal?
+        @matrix[i][j] = value
+      else
+        raise MatrixIndexOutOfRange, 'The matrix must be orthogonal.'
+      end
+    end
+  end

data/lib/matrix_gem/properties_module.rb

@@ -1,9 +1,44 @@
 module Properties
+
+  include MatrixErr
+
   # Returns an array of arrays that describe the rows of the matrix.
   def to_a
     self
   end
 
+  # Make all values floating point.
+  def to_f
+    (0..self.n - 1).each{ |i| (0..self.m - 1).each do
+      |j| self[i,j] = self[i,j].to_f
+      end }
+    self
+  end
+
+  # Return array with values on main diagonal.
+  def diagonal_values
+    size = ([self.m, self.n].min) -1
+    values = []
+
+    (0..size).each do |i|
+      values << self[i][i]
+    end
+    values
+  end
+
+  # Set values on main diagonal.
+  # Raise error if nums are less than matrix main diagonal length
+  # Also aliased as set_diagonal_values
+  def set_diagonal(*nums)
+    size = ([self.m, self.n].min) -1
+    raise MatrixArgumentError, 'Wrong number of arguments.' if nums.length < size + 1
+    (0..size).each do |i|
+      self[i,i] = nums[i]
+    end
+    self
+  end
+  alias set_diagonal_values set_diagonal
+
   # Returns the number of columns.
   # Also aliased as n(), col_size(), column_count()
   def col_length
@@ -27,21 +62,70 @@ module Properties
   alias col_size col_length
   alias column_count n
 
-  # Retun row on index.
+  # Retuns array with row on index as values.
   def row(index)
     self[index]
   end
 
-  # Set value of matrix row.
-  def row_change(index, elements)
+  # Returns array with column on index as values.
+  # Also aliased as column()
+  def col(index)
+    column = []
+    (0..self.m-1).each{ |x| column << self[x, index] }
+    column
+  end
+  alias column col
+
+  # Set values of matrix row. Elements shoud be an array of values
+  # Raise error if length of elements is not equal to matrix row length.
+  def set_row(index, elements)
+    raise MatrixArgumentError, 'Different length of elements and row length' if
+    elements.length != self.row_length
     self[index] = elements
+    self
   end
 
-  # Return col on index
-  # Also aliased as column()
-  def col(index)
-    self.each { |a| p a[index] }
+  # Set values of matrix column. Elements shoud be an array of values.
+  # Raise error if length of elements is not equal to matrix column length.
+  def set_col(index, elements)
+    raise MatrixArgumentError, 'Different length of elements and column length' if elements.length != self.col_length
+    (0..self.m-1).each{ |x| self[x, index] = elements[x] }
+    self
   end
 
-  alias column col
+  # Returns true if there is values not equal to 0 only on main diagonal.
+  # Also aliased as diagonal?
+  def is_diagonal
+    (0..self.m-1).each do |i|
+      (0..self.m-1).each do |j|
+        return false if ((self[i,j] != 0 && i != j))
+      end
+    end
+    true
+  end
+  alias diagonal? is_diagonal
+
+  # Returns true if this is a matrix with only zero elements.
+  # Also aliased as is_zero
+  def zero?
+    self.map{ |x| return false if x != 0 }
+    true
+  end
+  alias is_zero zero?
+
+  # Returns true if this is a matrix with equal rows and columns.
+  # Also aliased as square?
+  def is_square
+    return false if self.m != self.n
+    true
+  end
+  alias square? is_square
+
+  # Returns true if this is square matrix and its transpose is equal to its inverse.
+  # Also aliased as is_zero
+  def orthogonal?
+    return true if ((self.is_square) && (self.transposed == self.inversed))
+    false
+  end
+  alias is_orthogonal orthogonal?
 end

data/lib/matrix_gem.rb

@@ -1,305 +1,6 @@
-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
-
-#
-
-
-
-
-
-
-
-
-
-
-
+require_relative './matrix_gem/matrix_err'
+require_relative './matrix_gem/properties_module'
+require_relative './matrix_gem/matrix'
+require_relative './matrix_gem/diagonal_matrix'
+require_relative './matrix_gem/orthogonal_matrix'
 

metadata

@@ -1,23 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: matrix_gem
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Bozhidar Grigorov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-11 00:00:00.000000000 Z
-dependencies: []
+date: 2015-02-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
 description: Gem for work with matrices
 email: bojko002@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- Rakefile
 - lib/matrix_gem.rb
+- lib/matrix_gem/diagonal_matrix.rb
+- lib/matrix_gem/matrix.rb
 - lib/matrix_gem/matrix_err.rb
+- lib/matrix_gem/orthogonal_matrix.rb
 - lib/matrix_gem/properties_module.rb
 homepage: http://rubygems.org/gems/matrix_gem
 licenses: