fast_matrix 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3980488dbfc0f63bc9c5581eb26026e79e6b1a7e7a0215e610c19e0b2c403341
+  data.tar.gz: 19c9066e3d2dcd0200a30e17eeeb757f62622cdf004e4df5610c7b2e80b67da8
+SHA512:
+  metadata.gz: f8ad8b5b92b9deaee09e3dff8c1834459711fda976b83b26347ae154ad34bdebdf519228f121ada1a706d3beafe332ecc2259cbefaf77f4054f52f7b3db1fea0
+  data.tar.gz: feea35ee89d7510a221ba19e7c232f178e885b25afa2e051f3578dbcd6da3891e60472b3c5267ab2ec7450d509140bfaffaf97c1b1f8065cd01825a8148a034d

data/.dockerignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.idea/
+*.gem
+Gemfile.lock
+*.so
+*.md
+*Dockerfile

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea/
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.5
+before_install: gem install bundler -v 2.0.2
+deploy:
+  provider: rubygems
+  api_key: $API_KEY
+  gem: fast_matrix
+  on:
+    tags: true
+    repo: mmcs-ruby/fast_matrix

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at wolwerine@yandex.ru. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Dockerfile

@@ -0,0 +1,18 @@
+FROM ruby:2.6.5
+
+RUN gem install bundler -v 2.0.2
+
+WORKDIR /usr/src/app
+
+COPY Gemfile fast_matrix.gemspec ./
+COPY lib/fast_matrix ./lib/fast_matrix
+RUN bundle install
+
+COPY Rakefile ./
+COPY ext/ ./ext
+RUN rake compile
+
+COPY . .
+RUN rake test
+
+CMD /bin/bash

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in fast_matrix.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 wolwer1ne
+
+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,43 @@
+[![Build Status](https://travis-ci.org/mmcs-ruby/fast_matrix.svg?branch=master)](https://travis-ci.org/mmcs-ruby/fast_matrix)
+
+# FastMatrix
+
+Ruby wrapper around C matrices implementation written as exercise by two MMCS students.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fast_matrix'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fast_matrix
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/mmcs-ruby/fast_matrix. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the FastMatrix project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/mmcs-ruby/fast_matrix/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+require "rake/extensiontask"
+
+task :build => :compile
+
+Rake::ExtensionTask.new("fast_matrix") do |ext|
+  ext.lib_dir = "lib/fast_matrix"
+end
+
+task :default => [:clobber, :compile, :test]

data/bin/console

@@ -0,0 +1,14 @@
+#!/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

@@ -0,0 +1,8 @@
+#!/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/ext/fast_matrix/c_array_opeartions.c

@@ -0,0 +1,31 @@
+#include "c_array_operations.h"
+
+void fill_d_array(int len, double* a, double v)
+{
+    for(int i = 0; i < len; ++i)
+        a[i] = v;
+}
+
+void multiply_d_array(int len, double* a, double v)
+{
+    for(int i = 0; i < len; ++i)
+        a[i] *= v;
+}
+
+void copy_d_array(int len, const double* input, double* output)
+{
+    for(int i = 0; i < len; ++i)
+        output[i] = input[i];
+}
+
+void add_d_arrays_to_result(int len, const double* a1, const double* a2, double* result)
+{
+    for(int i = 0; i < len; ++i)
+        result[i] = a1[i] + a2[i];
+}
+
+void add_d_arrays_to_first(int len, double* sum, const double* added)
+{
+    for(int i = 0; i < len; ++i)
+        sum[i] += added[i];
+}

data/ext/fast_matrix/c_array_operations.h

@@ -0,0 +1,10 @@
+#ifndef C_ARRAY_OPERATIONS
+#define C_ARRAY_OPERATIONS
+
+void fill_d_array(int len, double* a, double v);
+void multiply_d_array(int len, double* a, double v);
+void copy_d_array(int len, const double* input, double* output);
+void add_d_arrays_to_result(int len, const double* a1, const double* a2, double* result);
+void add_d_arrays_to_first(int len, double* sum, const double* added);
+
+#endif  /*C_ARRAY_OPERATIONS*/

data/ext/fast_matrix/extconf.rb

@@ -0,0 +1,3 @@
+require "mkmf"
+
+create_makefile("fast_matrix/fast_matrix")

data/ext/fast_matrix/fast_matrix.c

@@ -0,0 +1,8 @@
+#include "fast_matrix.h"
+#include <stdio.h>
+
+
+void Init_fast_matrix()
+{
+    init_fm_matrix();
+}

data/ext/fast_matrix/fast_matrix.h

@@ -0,0 +1,8 @@
+#ifndef FAST_MATRIX_H
+#define FAST_MATRIX_H 1
+
+#include "matrix.h"
+
+void Init_fast_matrix();
+
+#endif /* FAST_MATRIX_H */

data/ext/fast_matrix/matrix.c

@@ -0,0 +1,289 @@
+#include "matrix.h"
+#include "c_array_operations.h"
+
+void matrix_free(void* data)
+{
+	free(((*(struct matrix*)data)).data);
+    free(data);
+}
+
+size_t matrix_size(const void* data)
+{
+	return sizeof(struct matrix);
+}
+
+VALUE matrix_alloc(VALUE self)
+{
+	struct matrix* mtx = malloc(sizeof(struct matrix));
+
+	return TypedData_Wrap_Struct(self, &matrix_type, mtx);
+}
+
+double raise_rb_value_to_double(VALUE v)
+{
+    if(RB_FLOAT_TYPE_P(v) || FIXNUM_P(v)
+        || RB_TYPE_P(v, T_BIGNUM))
+        return NUM2DBL(v);
+
+    rb_raise(matrix_eTypeError, "Value is not number");
+    return 0;
+}
+
+int raise_rb_value_to_int(VALUE v)
+{
+    if(FIXNUM_P(v))
+        return NUM2INT(v);
+
+    rb_raise(matrix_eTypeError, "Index is not integer");
+    return 0;
+}
+
+void raise_check_range(int v, int min, int max)
+{
+    if(v < min || v >= max)
+        rb_raise(matrix_eIndexError, "Index out of range");
+}
+
+void c_matrix_init(struct matrix* mtr, int m, int n)
+{
+    mtr->m = m;
+    mtr->n = n;
+    mtr->data = malloc(m * n * sizeof(double));
+}
+
+VALUE matrix_initialize(VALUE self, VALUE rows_count, VALUE columns_count)
+{
+	struct matrix* data;
+    int m = raise_rb_value_to_int(columns_count);
+    int n = raise_rb_value_to_int(rows_count);
+
+    if(m <= 0 || n <= 0)
+        rb_raise(matrix_eIndexError, "Size cannot be negative or zero");
+
+	TypedData_Get_Struct(self, struct matrix, &matrix_type, data);
+
+    c_matrix_init(data, m, n);
+
+	return self;
+}
+
+//  []=
+VALUE matrix_set(VALUE self, VALUE row, VALUE column, VALUE v)
+{
+    int m = raise_rb_value_to_int(column);
+    int n = raise_rb_value_to_int(row);
+    double x = raise_rb_value_to_double(v);
+
+	struct matrix* data;
+	TypedData_Get_Struct(self, struct matrix, &matrix_type, data);
+
+    raise_check_range(m, 0, data->m);
+    raise_check_range(n, 0, data->n);
+
+    data->data[m + data->m * n] = x;
+    return v;
+}
+
+//  []
+VALUE matrix_get(VALUE self, VALUE row, VALUE column)
+{
+    int m = raise_rb_value_to_int(column);
+    int n = raise_rb_value_to_int(row);
+
+	struct matrix* data;
+	TypedData_Get_Struct(self, struct matrix, &matrix_type, data);
+
+    raise_check_range(m, 0, data->m);
+    raise_check_range(n, 0, data->n);
+
+    return DBL2NUM(data->data[m + data->m * n]);
+}
+
+// in  - matrix m x n
+// out - matrix n x m
+void matrix_transpose(int m, int n, const double* in, double* out)
+{
+    for(int i = 0; i < m; ++i)
+        for(int j = 0; j < n; ++j)
+            out[j + n * i] = in[i + m * j];
+}
+
+// A - matrix k x n
+// B - matrix m x k
+// C - matrix m x n
+void c_matrix_multiply(int n, int k, int m, const double* A, const double* B, double* C)
+{
+
+    fill_d_array(m * n, C, 0);
+
+    for(int j = 0; j < n; ++j)
+    {
+        double* p_c = C + m * j;
+        const double* p_a = A + k * j;
+
+        for(int t = 0; t < k; ++t)
+        {
+            const double* p_b = B + m * t;
+            double d_a = p_a[t];
+            for(int i = 0; i < m; ++i)
+            {
+                p_c[i] += d_a * p_b[i];
+            }
+        }
+    }
+}
+
+VALUE matrix_multiply_mm(VALUE self, VALUE other)
+{
+	struct matrix* A;
+    struct matrix* B;
+	TypedData_Get_Struct(self, struct matrix, &matrix_type, A);
+	TypedData_Get_Struct(other, struct matrix, &matrix_type, B);
+
+    if(A->m != B->n)
+        rb_raise(matrix_eIndexError, "First columns differs from second rows");
+
+    int m = B->m;
+    int k = A->m;
+    int n = A->n;
+
+    struct matrix* C;
+    VALUE result = TypedData_Make_Struct(cMatrix, struct matrix, &matrix_type, C);
+
+    c_matrix_init(C, m, n);
+    c_matrix_multiply(n, k, m, A->data, B->data, C->data);
+
+    return result;
+}
+
+VALUE matrix_multiply_mn(VALUE self, VALUE value)
+{
+	struct matrix* A;
+	TypedData_Get_Struct(self, struct matrix, &matrix_type, A);
+
+    double d = NUM2DBL(value);
+
+    struct matrix* R;
+    VALUE result = TypedData_Make_Struct(cMatrix, struct matrix, &matrix_type, R);
+
+    c_matrix_init(R, A->m, A->n);
+    copy_d_array(A->m * A->n, A->data, R->data);
+    multiply_d_array(R->m * R->n, R->data, d);
+
+    return result;
+}
+
+VALUE matrix_multiply(VALUE self, VALUE v)
+{
+    if(RB_FLOAT_TYPE_P(v) || FIXNUM_P(v)
+        || RB_TYPE_P(v, T_BIGNUM))
+        return matrix_multiply_mn(self, v);
+    return matrix_multiply_mm(self, v);
+}
+
+VALUE matrix_copy(VALUE mtrx)
+{
+	struct matrix* M;
+	TypedData_Get_Struct(mtrx, struct matrix, &matrix_type, M);
+
+    struct matrix* R;
+    VALUE result = TypedData_Make_Struct(cMatrix, struct matrix, &matrix_type, R);
+
+    c_matrix_init(R, M->m, M->n);
+    copy_d_array(M->m * M->n, M->data, R->data);
+
+    return result;
+}
+
+VALUE row_size(VALUE self)
+{
+	struct matrix* data;
+	TypedData_Get_Struct(self, struct matrix, &matrix_type, data);
+    return INT2NUM(data->m);
+}
+
+VALUE column_size(VALUE self)
+{
+	struct matrix* data;
+	TypedData_Get_Struct(self, struct matrix, &matrix_type, data);
+    return INT2NUM(data->n);
+}
+
+VALUE transpose(VALUE self)
+{
+	struct matrix* M;
+	TypedData_Get_Struct(self, struct matrix, &matrix_type, M);
+
+    struct matrix* R;
+    VALUE result = TypedData_Make_Struct(cMatrix, struct matrix, &matrix_type, R);
+
+    c_matrix_init(R, M->n, M->m);
+    matrix_transpose(M->m, M->n, M->data, R->data);
+
+    return result;
+}
+
+VALUE add_with(VALUE self, VALUE value)
+{
+	struct matrix* A;
+    struct matrix* B;
+	TypedData_Get_Struct(self, struct matrix, &matrix_type, A);
+	TypedData_Get_Struct(value, struct matrix, &matrix_type, B);
+
+    if(A->m != B->m && A->m != B->m)
+        rb_raise(matrix_eIndexError, "Different sizes matrices");
+
+    int m = B->m;
+    int n = A->n;
+
+    struct matrix* C;
+    VALUE result = TypedData_Make_Struct(cMatrix, struct matrix, &matrix_type, C);
+
+    c_matrix_init(C, m, n);
+    add_d_arrays_to_result(n * m, A->data, B->data, C->data);
+
+    return result;
+}
+
+
+VALUE add_from(VALUE self, VALUE value)
+{
+	struct matrix* A;
+    struct matrix* B;
+	TypedData_Get_Struct(self, struct matrix, &matrix_type, A);
+	TypedData_Get_Struct(value, struct matrix, &matrix_type, B);
+
+    if(A->m != B->m && A->m != B->m)
+        rb_raise(matrix_eIndexError, "Different sizes matrices");
+
+    int m = B->m;
+    int n = A->n;
+
+    add_d_arrays_to_first(n * m, A->data, B->data);
+
+    return self;
+}
+
+void init_fm_matrix()
+{
+    VALUE  mod = rb_define_module("FastMatrix");
+	cMatrix = rb_define_class_under(mod, "Matrix", rb_cData);
+
+    matrix_eTypeError  = rb_define_class_under(cMatrix, "TypeError",  rb_eTypeError);
+    matrix_eIndexError = rb_define_class_under(cMatrix, "IndexError", rb_eIndexError);
+
+
+	rb_define_alloc_func(cMatrix, matrix_alloc);
+
+	rb_define_method(cMatrix, "initialize", matrix_initialize, 2);
+	rb_define_method(cMatrix, "[]", matrix_get, 2);
+	rb_define_method(cMatrix, "[]=", matrix_set, 3);
+	rb_define_method(cMatrix, "*", matrix_multiply, 1);
+	rb_define_method(cMatrix, "column_count", row_size, 0);
+	rb_define_method(cMatrix, "row_count", column_size, 0);
+	rb_define_method(cMatrix, "copy", matrix_copy, 0);
+	rb_define_method(cMatrix, "transpose", transpose, 0);
+
+	rb_define_method(cMatrix, "+", add_with, 1);
+	rb_define_method(cMatrix, "+=", add_from, 1);
+}

data/ext/fast_matrix/matrix.h

@@ -0,0 +1,43 @@
+#ifndef FAST_MATRIX_MATRIX_H
+#define FAST_MATRIX_MATRIX_H 1
+
+#include "ruby.h"
+
+static VALUE matrix_eTypeError;
+static VALUE matrix_eIndexError;
+static VALUE cMatrix;
+
+// matrix
+//     m --->
+//   [ 0,    1, ..,  m-1]
+// n [ m,  m+1, .., 2m-1]
+// | [2m, 2m+1, .., 3m-1]
+// V [ . . . . .
+//         . . . .  nm-1]
+struct matrix
+{
+    int m;
+    int n;
+
+    double* data;
+};
+
+void matrix_free(void* data);
+size_t matrix_size(const void* data);
+
+static const rb_data_type_t matrix_type =
+{
+	.wrap_struct_name = "matrix",
+	.function =
+    {
+		.dmark = NULL,
+		.dfree = matrix_free,
+		.dsize = matrix_size,
+	},
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+void init_fm_matrix();
+
+#endif /* FAST_MATRIX_MATRIX_H */

data/fast_matrix.gemspec

@@ -0,0 +1,33 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "fast_matrix/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "fast_matrix"
+  spec.version       = FastMatrix::VERSION
+  spec.authors       = ["mmcs_ruby"]
+  spec.email         = ["poganesyan@sfedu.ru"]
+
+  spec.summary       = %q{Ruby wrapper around C matrices implementation}
+  spec.description   = %q{Ruby wrapper around C matrices implementation}
+  spec.homepage      = "https://github.com/mmcs-ruby/fast_matrix"
+  spec.license       = "MIT"
+
+   spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/mmcs-ruby/fast_matrix"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/fast_matrix/extconf.rb"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

data/lib/constructors.rb

@@ -0,0 +1,109 @@
+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

data/lib/fast_matrix.rb

@@ -0,0 +1,72 @@
+require "fast_matrix/version"
+require "fast_matrix/fast_matrix"
+require "constructors"
+
+module FastMatrix
+  class Error < StandardError; end
+
+  # Matrix with fast implementations of + - * determinate in C
+  class Matrix
+
+    # Aliases just for capability with standard matrix
+    #
+    # Returns the number of rows.
+    #
+    alias_method :row_size, :row_count
+    #
+    # Returns the number of columns.
+    #
+    alias_method :column_size, :column_count
+
+    #
+    # 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/fast_matrix/version.rb

@@ -0,0 +1,3 @@
+module FastMatrix
+  VERSION = "0.1.2"
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: fast_matrix
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- mmcs_ruby
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-10-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Ruby wrapper around C matrices implementation
+email:
+- poganesyan@sfedu.ru
+executables: []
+extensions:
+- ext/fast_matrix/extconf.rb
+extra_rdoc_files: []
+files:
+- ".dockerignore"
+- ".gitignore"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Dockerfile
+- Gemfile
+- 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/extconf.rb
+- ext/fast_matrix/fast_matrix.c
+- ext/fast_matrix/fast_matrix.h
+- ext/fast_matrix/matrix.c
+- ext/fast_matrix/matrix.h
+- fast_matrix.gemspec
+- lib/constructors.rb
+- lib/fast_matrix.rb
+- lib/fast_matrix/version.rb
+homepage: https://github.com/mmcs-ruby/fast_matrix
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/mmcs-ruby/fast_matrix
+  source_code_uri: https://github.com/mmcs-ruby/fast_matrix
+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.7.6
+signing_key: 
+specification_version: 4
+summary: Ruby wrapper around C matrices implementation
+test_files: []