fast_matrix 0.1.4 → 0.1.5

data/lib/matrix/matrix.rb

@@ -0,0 +1,80 @@
+require 'matrix/constructors'
+
+module FastMatrix
+  # Matrix with fast implementations of + - * determinate in C
+  class Matrix
+
+    # Aliases just for compatibility with standard matrix
+    #
+    # Returns the number of rows.
+    #
+    alias row_size row_count
+    #
+    # Returns the number of columns.
+    #
+    alias column_size column_count
+    #
+    # Returns element (+i+,+j+) of the matrix.  That is: row +i+, column +j+.
+    #
+    alias element []
+    alias component []
+
+    def to_s
+      convert.to_s
+    end
+
+    def inspect
+      convert.inspect
+    end
+
+    #
+    # Create fast matrix from standard matrix
+    #
+    def self.convert(matrix)
+      fast_matrix = Matrix.new(matrix.row_count, matrix.column_count)
+      (0...matrix.row_count).each do |i|
+        (0...matrix.column_count).each do |j|
+          fast_matrix[i, j] = matrix[i, j]
+        end
+      end
+      fast_matrix
+    end
+
+    def each_with_index
+      (0...row_count).each do |i|
+        (0...column_count).each do |j|
+          yield self[i, j], i, j
+        end
+      end
+    end
+
+    def each_with_index!
+      (0...row_count).each do |i|
+        (0...column_count).each do |j|
+          self[i, j] = yield self[i, j], i, j
+        end
+      end
+      self
+    end
+
+    #
+    # Convert to standard ruby matrix.
+    #
+    def convert
+      ::Matrix.build(row_size, column_size) { |i, j| self[i, j] }
+    end
+
+    # FIXME: for compare with standard matrix
+    def ==(other)
+      # TODO: check class and use fast compare from C if possibly
+      return false unless %i[row_size column_size \[\]].all? { |x| other.respond_to? x }
+      return false unless self.row_size == other.row_size && self.column_size == other.column_size
+
+      result = true
+      each_with_index do |elem, i, j|
+        result &&= elem == other[i, j].to_f
+      end
+      result
+    end
+  end
+end

data/lib/vector/constructors.rb

@@ -0,0 +1,58 @@
+require 'fast_matrix/fast_matrix'
+require 'errors'
+
+module FastMatrix
+  class Vector
+    #
+    # Creates a Vector from a list of elements.
+    #   Vector[7, 4, ...]
+    #
+    def self.[](*elems)
+      vector = new(elems.size)
+      vector.each_with_index! { |_, idx| elems[idx] }
+      vector
+    end
+
+    #
+    # Creates a vector from an Array.
+    # The optional argument +copy+ exists only for compatibility with standard.
+    # The optional argument +copy+ cannot be false, unlike standard.
+    #
+    def self.elements(array, copy = true)
+      check_flag_copy(copy)
+      self[*array]
+    end
+
+    #
+    # Returns a standard basis +n+-vector, where k is the index.
+    #
+    #    Vector.basis(size, index) # => Vector[0, 1, 0]
+    #
+    def self.basis(size, index)
+      result = zero(size)
+      result[index] = 1
+      result
+    end
+
+    #
+    # Return a zero vector.
+    #
+    #    Vector.zero(3) => Vector[0, 0, 0]
+    #
+    def self.zero(size)
+      result = new(size)
+      result.each_with_index! { 0 }
+      result
+    end
+
+    class << Vector
+      private
+
+      def check_flag_copy(copy)
+        unless copy
+          raise NotSupportedError, "Can't create vector without copy elements"
+        end
+      end
+    end
+  end
+end

data/lib/vector/vector.rb

@@ -0,0 +1,20 @@
+require 'vector/constructors'
+
+module FastMatrix
+  class Vector
+
+    def each_with_index
+      (0...size).each do |i|
+        yield self[i], i
+      end
+    end
+
+    def each_with_index!
+      (0...size).each do |i|
+        self[i] = yield self[i], i
+      end
+      self
+    end
+
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fast_matrix
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - mmcs_ruby
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-10-24 00:00:00.000000000 Z
+date: 2019-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -83,19 +83,25 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- bin/console
-- bin/setup
 - ext/fast_matrix/c_array_opeartions.c
 - ext/fast_matrix/c_array_operations.h
+- ext/fast_matrix/errors.c
+- ext/fast_matrix/errors.h
 - ext/fast_matrix/extconf.rb
 - ext/fast_matrix/fast_matrix.c
 - ext/fast_matrix/fast_matrix.h
 - ext/fast_matrix/matrix.c
 - ext/fast_matrix/matrix.h
+- ext/fast_matrix/vector.c
+- ext/fast_matrix/vector.h
 - fast_matrix.gemspec
-- lib/constructors.rb
+- lib/errors.rb
 - lib/fast_matrix.rb
 - lib/fast_matrix/version.rb
+- lib/matrix/constructors.rb
+- lib/matrix/matrix.rb
+- lib/vector/constructors.rb
+- lib/vector/vector.rb
 homepage: https://github.com/mmcs-ruby/fast_matrix
 licenses:
 - MIT

data/bin/console

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-require "fast_matrix"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start(__FILE__)

data/bin/setup

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install
-
-# Do any other automated setup that you need to do here

data/lib/constructors.rb

@@ -1,109 +0,0 @@
-require "fast_matrix/version"
-
-module FastMatrix
-  class Matrix
-
-    #
-    # Creates a matrix of size +row_count+ x +column_count+.
-    # It fills the values by calling the given block,
-    # passing the current row and column.
-    # Returns an enumerator if no block is given.
-    #
-    #   m = Matrix.build(2, 4) {|row, col| col - row }
-    #     => Matrix[[0, 1, 2, 3], [-1, 0, 1, 2]]
-    #   m = Matrix.build(3) { rand }
-    #     => a 3x3 matrix with random elements
-    #
-    def self.build(row_count, column_count = row_count, &block)
-      matrix = self.new(row_count, column_count)
-      matrix.each_with_index! { |_, i, j| block.call(i, j) }
-    end
-      #
-    # Creates a matrix where each argument is a row.
-    #   Matrix[ [25, 93], [-1, 66] ]
-    #      =>  25 93
-    #          -1 66
-    #
-    def self.[](*rows)
-      columns_count = rows[0].size
-      rows_count = rows.size
-      matrix = Matrix.new(rows_count, columns_count)
-      matrix.each_with_index! { |_, i, j| rows[i][j] }
-      matrix
-    end
-
-    #
-    # Creates a single-column matrix where the values of that column are as given
-    # in +column+.
-    #   Matrix.column_vector([4,5,6])
-    #     => 4
-    #        5
-    #        6
-    #
-    def self.column_vector(column)
-      matrix = Matrix.new(column.size, 1)
-      column.each_with_index { |elem, i| matrix[i, 0] = elem }
-      matrix
-    end
-
-    #
-    # Creates a single-row matrix where the values of that row are as given in
-    # +row+.
-    #   Matrix.row_vector([4,5,6])
-    #     => 4 5 6
-    #
-    def self.row_vector(row)
-      matrix = Matrix.new(1, row.size)
-      row.each_with_index { |elem, j| matrix[0, j] = elem }
-      matrix
-    end
-
-    #
-    # Creates a matrix where the diagonal elements are composed of +values+.
-    #   Matrix.diagonal(9, 5, -3)
-    #     =>  9  0  0
-    #         0  5  0
-    #         0  0 -3
-    #
-    def self.diagonal(*values)
-      matrix = Matrix.new(values.size, values.size)
-      matrix.each_with_index! { |_, i, j| i == j ? values[i] : 0 }
-      matrix
-    end
-
-    #
-    # Creates an +n+ by +n+ diagonal matrix where each diagonal element is
-    # +value+.
-    #   Matrix.scalar(2, 5)
-    #     => 5 0
-    #        0 5
-    #
-    def self.scalar(n, value)
-      matrix = Matrix.new(n, n)
-      matrix.each_with_index! { |_, i, j| i == j ? value : 0 }
-      matrix
-    end
-
-    #
-    # Creates an +n+ by +n+ identity matrix.
-    #   Matrix.identity(2)
-    #     => 1 0
-    #        0 1
-    #
-    def self.identity(n)
-      scalar(n, 1)
-    end
-
-    #
-    # Creates a zero matrix +n+ by +n+.
-    #   Matrix.zero(2)
-    #     => 0 0
-    #        0 0
-    #
-    def self.zero(n)
-      matrix = Matrix.new(n, n)
-      matrix.each_with_index! { |_, _, _| 0 }
-      matrix
-    end
-  end
-end