fast_matrix 0.1.66 → 0.2.0

data/ext/fast_matrix/{vector.h → Vector/vector.h}

@@ -5,16 +5,6 @@
 
 extern VALUE cVector;
 extern const rb_data_type_t vector_type;
-
-// vector
-struct vector
-{
-    int n;
-    double* data;
-};
-
-void c_vector_init(struct vector* vect, int n);
-
 void init_fm_vector();
 
 #endif /* FAST_MATRIX_VECTOR_H */

data/ext/fast_matrix/c_include.c

@@ -0,0 +1,8 @@
+#include "Helper/errors.c"
+#include "Helper/c_array_opeartions.c"
+
+#include "Matrix/matrix.c"
+#include "Matrix/c_matrix.c"
+
+#include "Vector/vector.c"
+#include "Vector/c_vector.c"

data/ext/fast_matrix/fast_matrix.h

@@ -1,9 +1,9 @@
 #ifndef FAST_MATRIX_H
 #define FAST_MATRIX_H 1
 
-#include "errors.h"
-#include "matrix.h"
-#include "vector.h"
+#include "Helper/errors.h"
+#include "Matrix/matrix.h"
+#include "Vector/vector.h"
 
 void Init_fast_matrix();
 

data/fast_matrix.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
 
   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.homepage      = "https://github.com/mmcs-ruby/fast_matrix/wiki"
   spec.license       = "MIT"
 
    spec.metadata["homepage_uri"] = spec.homepage

data/lib/fast_matrix/version.rb

@@ -1,3 +1,3 @@
 module FastMatrix
-  VERSION = '0.1.66'
+  VERSION = '0.2.0'
 end

data/lib/matrix/constructors.rb

@@ -95,17 +95,6 @@ module FastMatrix
       build(values.size, values.size) { |i, j| i == j ? values[i] : 0 }
     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)
-      build(n, n) { |i, j| i == j ? value : 0 }
-    end
-
     #
     # Creates an +n+ by +n+ identity matrix.
     #   Matrix.identity(2)
@@ -147,58 +136,6 @@ module FastMatrix
       raise NotSupportedError, 'Empty matrices does not supported'
     end
 
-    #
-    # Create a matrix by stacking matrices vertically
-    #
-    #   x = Matrix[[1, 2], [3, 4]]
-    #   y = Matrix[[5, 6], [7, 8]]
-    #   Matrix.vstack(x, y) # => Matrix[[1, 2], [3, 4], [5, 6], [7, 8]]
-    # TODO: optimize (maybe in C)
-    def self.vstack(x, *matrices)
-      column_count = x.column_count
-      row_count = x.row_count
-      matrices.each do |matrix|
-        raise IndexError unless matrix.column_count == column_count
-
-        row_count += matrix.row_count
-      end
-      result = new(row_count, column_count)
-      m_i = 0
-      [x, *matrices].each do |matrix|
-        matrix.each_with_index do |elem, i, j|
-          result[m_i + i, j] = elem
-        end
-        m_i += matrix.row_count
-      end
-      result
-    end
-
-    #
-    # Create a matrix by stacking matrices horizontally
-    #
-    #   x = Matrix[[1, 2], [3, 4]]
-    #   y = Matrix[[5, 6], [7, 8]]
-    #   Matrix.hstack(x, y) # => Matrix[[1, 2, 5, 6], [3, 4, 7, 8]]
-    #
-    def self.hstack(x, *matrices)
-      column_count = x.column_count
-      row_count = x.row_count
-      matrices.each do |matrix|
-        raise IndexError unless matrix.row_count == row_count
-
-        column_count += matrix.column_count
-      end
-      result = new(row_count, column_count)
-      m_j = 0
-      [x, *matrices].each do |matrix|
-        matrix.each_with_index do |elem, i, j|
-          result[i, m_j + j] = elem
-        end
-        m_j += matrix.column_count
-      end
-      result
-    end
-
     #
     # Create a matrix by combining matrices entrywise, using the given block
     #

data/lib/matrix/matrix.rb

@@ -19,14 +19,30 @@ module FastMatrix
     alias element []
     alias component []
 
-    def to_s
-      convert.to_s
+    def collect
+      collected_rows = []
+      rows.each do |i|
+        collected_rows.push(yield i)
+      end
+      collected_rows
     end
 
-    def inspect
-      convert.inspect
+    #
+    # Overrides Object#to_s
+    #
+    def to_s
+      "#{self.class}[#{collect do |row|
+        '[' + row.join(', ') + ']'
+      end.join(', ')}]"
     end
 
+    alias to_str to_s
+    alias inspect to_str
+
+    def to_a
+      rows.collect(&:dup)
+    end
+    
     #
     # Create fast matrix from standard matrix
     #
@@ -40,14 +56,85 @@ module FastMatrix
       fast_matrix
     end
 
+    #
+    # Yields all elements of the matrix, starting with those of the first row
+    #
+    #   Matrix[ [1,2], [3,4] ].each { |e| puts e }
+    #     # => prints the numbers 1 to 4
+     def each(which = :all) # :yield: e
+        return to_enum :each, which unless block_given?
+        case which
+        when :all
+          (0...row_count).each do |i|
+            (0...column_count).each do |j|
+              yield self[i, j]
+            end
+          end
+        when :diagonal
+          (0...[row_count, column_count].min).each do |i|
+                yield self[i, i]
+          end
+        when :off_diagonal
+          (0...row_count).each do |i|
+            (0...column_count).each do |j|
+              if i != j
+                yield self[i, j]
+              end
+            end
+          end
+        when :lower
+          (0...row_count).each do |i|
+            (0..[i,column_count-1].min).each do |j|
+              yield self[i, j]
+            end
+          end
+        when :strict_lower
+          (1...row_count).each do |i|
+            (0...[i,column_count].min).each do |j|
+                yield self[i, j]
+            end
+          end
+        when :strict_upper
+          (0...row_count).each do |i|
+            (i+1...column_count).each do |j|
+              yield self[i, j]
+            end
+          end
+        when :upper
+          (0...row_count).each do |i|
+            (i...column_count).each do |j|
+              yield self[i, j]
+            end
+          end
+        else
+          raise ArgumentError, "expected #{which.inspect} to be one of :all, :diagonal, :off_diagonal, :lower, :strict_lower, :strict_upper or :upper"
+        end
+        self
+      end
+    #
+    # Same as #each, but the row index and column index in addition to the element
+    #
+    #   Matrix[ [1,2], [3,4] ].each_with_index do |e, row, col|
+    #     puts "#{e} at #{row}, #{col}"
+    #   end
+    #     # => Prints:
+    #     #    1 at 0, 0
+    #     #    2 at 0, 1
+    #     #    3 at 1, 0
+    #     #    4 at 1, 1
+    #
     def each_with_index
+      raise NotSupportedError unless block_given?
+
       (0...row_count).each do |i|
         (0...column_count).each do |j|
           yield self[i, j], i, j
         end
       end
+      self
     end
 
+    # don't use (Issue#1)
     def each_with_index!
       (0...row_count).each do |i|
         (0...column_count).each do |j|
@@ -76,5 +163,19 @@ module FastMatrix
       end
       result
     end
+
+    private
+
+    def rows
+      rows = []
+      (0...row_count).each do |i|
+        row = []
+        (0...column_count).each do |j|
+          row.push(element(i, j))
+        end
+        rows.push(row)
+      end
+      rows
+    end
   end
 end

data/lib/vector/constructors.rb

@@ -26,9 +26,11 @@ module FastMatrix
     #
     # Returns a standard basis +n+-vector, where k is the index.
     #
-    #    Vector.basis(size, index) # => Vector[0, 1, 0]
+    #    Vector.basis(size:, index:) # => Vector[0, 1, 0]
     #
-    def self.basis(size, index)
+    def Vector.basis(size:, index:)
+      raise IndexError, "invalid size (#{size} for 1..)" if size < 1
+      raise IndexError, "invalid index (#{index} for 0...#{size})" unless 0 <= index && index < size    
       result = zero(size)
       result[index] = 1
       result
@@ -41,8 +43,7 @@ module FastMatrix
     #
     def self.zero(size)
       result = new(size)
-      result.each_with_index! { 0 }
-      result
+      result.fill!(0)
     end
 
     class << Vector

data/lib/vector/vector.rb

@@ -21,12 +21,32 @@ module FastMatrix
       Array.new(size) { |i| self[i] }
     end
 
+    def to_s
+      "#{self.class}[#{to_ary.join(', ')}]"
+    end
+    alias to_str to_s
+    alias inspect to_str
+
+    #
+    # Iterate over the elements of this vector
+    #
+    def each
+      raise NotSupportedError unless block_given?
+
+      (0...size).each do |i|
+        yield self[i]
+      end
+      self
+    end
+
     def each_with_index
       (0...size).each do |i|
         yield self[i], i
       end
+      self
     end
 
+    # don't use (Issue#1)
     def each_with_index!
       (0...size).each do |i|
         self[i] = yield self[i], i
@@ -46,5 +66,14 @@ module FastMatrix
       end
       result
     end
+
+    def independent?(*vs)
+      vs << self
+      Vector.independent?(*vs)
+    end
+
+    def cross_product(*vs)
+      Vector.cross_product(self, *vs)
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fast_matrix
 version: !ruby/object:Gem::Version
-  version: 0.1.66
+  version: 0.2.0
 platform: ruby
 authors:
 - mmcs_ruby
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-10-29 00:00:00.000000000 Z
+date: 2019-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -97,17 +97,26 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- 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/Helper/c_array_opeartions.c
+- ext/fast_matrix/Helper/c_array_operations.h
+- ext/fast_matrix/Helper/errors.c
+- ext/fast_matrix/Helper/errors.h
+- ext/fast_matrix/Matrix/c_matrix.c
+- ext/fast_matrix/Matrix/c_matrix.h
+- ext/fast_matrix/Matrix/errors.h
+- ext/fast_matrix/Matrix/helper.h
+- ext/fast_matrix/Matrix/matrix.c
+- ext/fast_matrix/Matrix/matrix.h
+- ext/fast_matrix/Vector/c_vector.c
+- ext/fast_matrix/Vector/c_vector.h
+- ext/fast_matrix/Vector/errors.h
+- ext/fast_matrix/Vector/helper.h
+- ext/fast_matrix/Vector/vector.c
+- ext/fast_matrix/Vector/vector.h
+- ext/fast_matrix/c_include.c
 - 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/errors.rb
 - lib/fast_matrix.rb
@@ -117,11 +126,11 @@ files:
 - lib/scalar.rb
 - lib/vector/constructors.rb
 - lib/vector/vector.rb
-homepage: https://github.com/mmcs-ruby/fast_matrix
+homepage: https://github.com/mmcs-ruby/fast_matrix/wiki
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/mmcs-ruby/fast_matrix
+  homepage_uri: https://github.com/mmcs-ruby/fast_matrix/wiki
   source_code_uri: https://github.com/mmcs-ruby/fast_matrix
 post_install_message: 
 rdoc_options: []

data/ext/fast_matrix/matrix.c

@@ -1,678 +0,0 @@
-#include "matrix.h"
-#include "c_array_operations.h"
-#include "errors.h"
-#include "vector.h"
-
-VALUE cMatrix;
-
-void matrix_free(void* data);
-size_t matrix_size(const void* data);
-
-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 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));
-    mtx->data = NULL;
-	return TypedData_Wrap_Struct(self, &matrix_type, mtx);
-}
-
-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(fm_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);
-    
-    m = (m < 0) ? data->m + m : m;
-    n = (n < 0) ? data->n + n : n;
-
-    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);
-    
-    m = (m < 0) ? data->m + m : m;
-    n = (n < 0) ? data->n + n : n;
-    
-    if(m < 0 || n < 0 || n >= data->n || m >= data->m)
-        return Qnil;
-
-    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];
-        }
-    }
-}
-
-// M - matrix m x n
-// V - vector m
-// R - vector n
-void c_matrix_vector_multiply(int n, int m, const double* M, const double* V, double* R)
-{
-    fill_d_array(n, R, 0);
-
-    for(int j = 0; j < n; ++j)
-    {
-        const double* p_m = M + m * j;
-        for(int i = 0; i < m; ++i)
-            R[j] += V[i] * p_m[i];
-    }
-}
-
-VALUE matrix_multiply_mv(VALUE self, VALUE other)
-{
-    struct matrix* M;
-    struct vector* V;
-    TypedData_Get_Struct(self, struct matrix, &matrix_type, M);
-    TypedData_Get_Struct(other, struct vector, &vector_type, V);
-
-    if(M->m != V->n)
-        rb_raise(fm_eIndexError, "Matrix columns differs from vector size");
-
-    int m = M->m;
-    int n = M->n;
-
-    struct vector* R;
-    VALUE result = TypedData_Make_Struct(cVector, struct vector, &vector_type, R);
-
-    c_vector_init(R, n);
-    c_matrix_vector_multiply(n, m, M->data, V->data, R->data);
-
-    return result;
-}
-
-// A - matrix k x n
-// B - matrix m x k
-// C - matrix m x n
-void strassen_iteration(int n, int k, int m, const double* A, const double* B, double* C, int s_a, int s_b, int s_c)
-{
-    for(int j = 0; j < n; ++j)
-    {
-        double* p_c = C + s_c * j;
-        const double* p_a = A + s_a * j;
-
-        for(int t = 0; t < k; ++t)
-        {
-            const double* p_b = B + s_b * t;
-            double d_a = p_a[t];
-            for(int i = 0; i < m; ++i)
-                p_c[i] += d_a * p_b[i];
-        }
-    }
-}
-
-bool check_strassen(int m, int n, int k)
-{
-    return n > 2 && m > 2 && k > 2 && (double)m * (double)n * (double)k > 100000000;
-}
-
-
-void strassen_copy(int m, int n, const double* A, double* B, int s_a, int s_b)
-{
-    for(int i = 0; i < n; ++i)
-    {
-        const double* p_A = A + i * s_a;
-        double* p_B = B + i * s_b;
-        for(int j = 0; j < m; ++j)
-            p_B[j] = p_A[j];
-    }
-}
-
-void strassen_sum_to_first(int m, int n, double* A, const double* B, int s_a, int s_b)
-{
-    for(int i = 0; i < n; ++i)
-    {
-        double* p_A = A + i * s_a;
-        const double* p_B = B + i * s_b;
-        for(int j = 0; j < m; ++j)
-            p_A[j] += p_B[j];
-    }
-}
-
-void strassen_sub_to_first(int m, int n, double* A, const double* B, int s_a, int s_b)
-{
-    for(int i = 0; i < n; ++i)
-    {
-        double* p_A = A + i * s_a;
-        const double* p_B = B + i * s_b;
-        for(int j = 0; j < m; ++j)
-            p_A[j] -= p_B[j];
-    }
-}
-
-// A - matrix k x n
-// B - matrix m x k
-// C - matrix m x n
-void recursive_strassen(int n, int k, int m, const double* A, const double* B, double* C)
-{
-    if(!check_strassen(m, n, k))
-        return c_matrix_multiply(n, k, m, A, B, C);
-
-    int k2 = k / 2;
-    int k1 = k - k2;
-    int m2 = m / 2;
-    int m1 = m - m2;
-    int n2 = n / 2;
-    int n1 = n - n2;
-
-    double* termA = malloc(k1 * n1 * sizeof(double));
-    double* termB = malloc(m1 * k1 * sizeof(double));
-
-    double* P1 = malloc(7 * m1 * n1 * sizeof(double));
-    double* P2 = P1 + m1 * n1;
-    double* P3 = P2 + m1 * n1;
-    double* P4 = P3 + m1 * n1;
-    double* P5 = P4 + m1 * n1;
-    double* P6 = P5 + m1 * n1;
-    double* P7 = P6 + m1 * n1;
-    fill_d_array(7 * m1 * n1, P1, 0);
-    fill_d_array(k1 * n1, termA, 0);
-    fill_d_array(m1 * k1, termB, 0);
-
-    //  -----------P1-----------
-    strassen_copy(k1, n1, A, termA, k, k1);
-    strassen_sum_to_first(k2, n2, termA, A + k1 + k * n1, k1, k);
-    
-    strassen_copy(m1, k1, B, termB, m, m1);
-    strassen_sum_to_first(m2, k2, termB, B + m1 + m * k1, m1, m);
-
-    recursive_strassen(n1, k1, m1, termA, termB, P1);
-    fill_d_array(k1 * n1, termA, 0);
-    //  -----------P2-----------
-    strassen_copy(k1, n2, A + k * n1, termA, k, k1);
-    strassen_sum_to_first(k2, n2, termA, A + k1 + k * n1, k1, k);
-    
-    strassen_copy(m1, k1, B, termB, m, m1);
-
-    recursive_strassen(n1, k1, m1, termA, termB, P2);
-    fill_d_array(m1 * k1, termB, 0);
-    //  -----------P3-----------
-    strassen_copy(k1, n1, A, termA, k, k1);
-    
-    strassen_copy(m2, k1, B + m1, termB, m, m1);
-    strassen_sub_to_first(m2, k2, termB, B + m1 + m * k1, m1, m);
-    
-    recursive_strassen(n1, k1, m1, termA, termB, P3);
-    fill_d_array(k1 * n1, termA, 0);
-    fill_d_array(m1 * k1, termB, 0);
-    //  -----------P4-----------
-    strassen_copy(k2, n2, A + k1 + k * n1, termA, k, k1);
-    
-    strassen_copy(m1, k2, B + m * k1, termB, m, m1);
-    strassen_sub_to_first(m1, k1, termB, B, m1, m);
-    
-    recursive_strassen(n1, k1, m1, termA, termB, P4);
-    fill_d_array(m1 * k1, termB, 0);
-    //  -----------P5-----------
-    strassen_copy(k1, n1, A, termA, k, k1);
-    strassen_sum_to_first(k2, n1, termA, A + k1, k1, k);
-    
-    strassen_copy(m2, k2, B + m1 + m * k1, termB, m, m1);
-    
-    recursive_strassen(n1, k1, m1, termA, termB, P5);
-    fill_d_array(k1 * n1, termA, 0);
-    //  -----------P6-----------
-    strassen_copy(k1, n2, A + k * n1, termA, k, k1);
-    strassen_sub_to_first(k1, n1, termA, A, k1, k);
-    
-    strassen_copy(m1, k1, B, termB, m, m1);
-    strassen_sum_to_first(m2, k1, termB, B + m1, m1, m);
-    
-    recursive_strassen(n1, k1, m1, termA, termB, P6);
-    fill_d_array(k1 * n1, termA, 0);
-    fill_d_array(m1 * k1, termB, 0);
-    //  -----------P7-----------
-    strassen_copy(k2, n1, A + k1, termA, k, k1);
-    strassen_sub_to_first(k2, n2, termA, A + k1 + k * n1, k1, k);
-    
-    strassen_copy(m1, k2, B + k1 * m, termB, m, m1);
-    strassen_sum_to_first(m2, k2, termB, B + m1 + m * k1, m1, m);
-    
-    recursive_strassen(n1, k1, m1, termA, termB, P7);
-
-    //  -----------C11-----------
-    double* C11 = C;
-    strassen_copy(m1, n1, P1, C11, m1, m);
-    strassen_sum_to_first(m1, n1, C11, P4, m, m1);
-    strassen_sub_to_first(m1, n1, C11, P5, m, m1);
-    strassen_sum_to_first(m1, n1, C11, P7, m, m1);
-    //  -----------C12-----------
-    double* C12 = C + m1;
-    strassen_copy(m2, n1, P3, C12, m1, m);
-    strassen_sum_to_first(m2, n1, C12, P5, m, m1);
-    //  -----------C21-----------
-    double* C21 = C + m * n1;
-    strassen_copy(m1, n2, P2, C21, m1, m);
-    strassen_sum_to_first(m1, n2, C21, P4, m, m1);
-    //  -----------C22-----------
-    double* C22 = C + m1 + m * n1;
-    strassen_copy(m2, n2, P1, C22, m1, m);
-    strassen_sub_to_first(m2, n2, C22, P2, m, m1);
-    strassen_sum_to_first(m2, n2, C22, P3, m, m1);
-    strassen_sum_to_first(m2, n2, C22, P6, m, m1);
-    
-    free(termA);
-    free(termB);
-    free(P1);
-}
-
-VALUE strassen(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(fm_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);
-    fill_d_array(m * n, C->data, 0);
-    recursive_strassen(n, k, m, A->data, B->data, C->data);
-    return result;
-}
-
-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(fm_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);
-    if(RBASIC_CLASS(v) == cMatrix)
-        return matrix_multiply_mm(self, v);
-    if(RBASIC_CLASS(v) == cVector);
-        return matrix_multiply_mv(self, v);
-    rb_raise(fm_eTypeError, "Invalid klass for multiply");
-}
-
-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 matrix_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->n != B->n)
-        rb_raise(fm_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 matrix_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->n != B->n)
-        rb_raise(fm_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;
-}
-
-
-VALUE matrix_sub_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->n != B->n)
-        rb_raise(fm_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);
-    sub_d_arrays_to_result(n * m, A->data, B->data, C->data);
-
-    return result;
-}
-
-double determinant(int n, const double* A)
-{
-    double* M = malloc(n * n * sizeof(double));
-    double det = 1;
-    copy_d_array(n * n, A, M);
-
-    for(int i = 0; i < n; ++i)
-    {
-        const double* line_p = M + i + i * n;
-        double current = *line_p; 
-        det *= current;
-
-        if(current == 0)
-        {
-            free(M);
-            return 0;
-        }
-
-        for(int j = i + 1; j < n; ++j)
-        {
-            double* t_line = M + i + j * n;
-            double head = *t_line;
-            for(int k = 1; k < n - i; ++k)
-                t_line[k] -= line_p[k] * head / current;
-        }
-    }
-
-    free(M);
-    return det;
-}
-
-VALUE matrix_determinant(VALUE self)
-{
-    struct matrix* A;
-    TypedData_Get_Struct(self, struct matrix, &matrix_type, A);
-
-    
-    int m = A->m;
-    int n = A->n;
-    if(m != n)
-        rb_raise(fm_eIndexError, "Not a square matrix");
-
-    return DBL2NUM(determinant(n, A->data));
-}
-
-VALUE matrix_sub_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->n != B->n)
-        rb_raise(fm_eIndexError, "Different sizes matrices");
-
-    int m = B->m;
-    int n = A->n;
-
-    sub_d_arrays_to_first(n * m, A->data, B->data);
-
-    return self;
-}
-
-VALUE matrix_fill(VALUE self, VALUE value)
-{
-    double d = raise_rb_value_to_double(value);
-	struct matrix* A;
-	TypedData_Get_Struct(self, struct matrix, &matrix_type, A);
-
-    fill_d_array(A->m * A->n, A->data, d);
-
-    return self;
-}
-
-VALUE matrix_equal(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->n != B->n || A->m != B->m)
-		return Qfalse;
-
-    int n = A->n;
-    int m = B->m;
-
-    if(equal_d_arrays(n * m, A->data, B->data))
-		return Qtrue;
-	return Qfalse;
-}
-
-VALUE matrix_abs(VALUE self)
-{
-	struct matrix* A;
-	TypedData_Get_Struct(self, struct matrix, &matrix_type, A);
-
-    int m = A->m;
-    int n = A->n;
-
-    struct matrix* B;
-    VALUE result = TypedData_Make_Struct(cMatrix, struct matrix, &matrix_type, B);
-
-    c_matrix_init(B, m, n);
-    abs_d_array(n * m, A->data, B->data);
-
-    return result;
-}
-
-VALUE matrix_greater_or_equal(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->n != B->n)
-        rb_raise(fm_eIndexError, "Different sizes matrices");
-
-    int m = B->m;
-    int n = A->n;
-
-    if(greater_or_equal_d_array(n * m, A->data, B->data))
-        return Qtrue;
-    return Qfalse;
-}
-
-void init_fm_matrix()
-{
-    VALUE  mod = rb_define_module("FastMatrix");
-	cMatrix = rb_define_class_under(mod, "Matrix", rb_cData);
-
-	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, "clone", matrix_copy, 0);
-	rb_define_method(cMatrix, "transpose", transpose, 0);
-	rb_define_method(cMatrix, "+", matrix_add_with, 1);
-	rb_define_method(cMatrix, "+=", matrix_add_from, 1);
-	rb_define_method(cMatrix, "-", matrix_sub_with, 1);
-	rb_define_method(cMatrix, "-=", matrix_sub_from, 1);
-	rb_define_method(cMatrix, "fill!", matrix_fill, 1);
-    rb_define_method(cMatrix, "strassen", strassen, 1);
-    rb_define_method(cMatrix, "abs", matrix_abs, 0);
-    rb_define_method(cMatrix, ">=", matrix_greater_or_equal, 1);
-    rb_define_method(cMatrix, "determinant", matrix_determinant, 0);
-    rb_define_method(cMatrix, "eql?", matrix_equal, 1);
-}