fast_matrix 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d2ffdbf4f0e25843620e0f1deef060ec8498cbd86571625bc265a20778b3fc8
-  data.tar.gz: 8574ff18ebbfc3763de8944d7697dfd3cdc17f6206581140dc27f6de207322bb
+  metadata.gz: 31d4bbeb84c105ff8d28f067b375ff1b89120589baf84d5cff5a175db54f1522
+  data.tar.gz: d8988e813b690465c0716b62b61cf36b71696381688bdcbcb008effd70235cc3
 SHA512:
-  metadata.gz: 98dc2ee472302bd8314ec63529c7b36065e09bb99ff2af62f063bcbd4d5af26cb88786a10f0c64737daa82d46613352af30cb2cb650b60e42ec2cd511d4a0310
-  data.tar.gz: 75b445494ab54d32f46d79b1c2e9fb95d0b5e5b091bbbe4e3ed339a38ee9c7fbe650c7fcf9537b083e26bb7bde96f14862cfaa84c00c2b0ca654ce7665d60965
+  metadata.gz: d5d202092bbf94928f067f6c600db6075d5b2b7ff7a703a71a6811c667fe40b102611d676b185ebfc267dafb958ac547b1c6a1bcddecf3411306997cea050663
+  data.tar.gz: e829008f0decdf7193fd96f561605496489fab34b0eb67d66ec9d6070c4fa1459a206d375ba529980842a30bc4ffd52b0b34b5eff55dff875dbc5885508170fd

data/.dockerignore

@@ -11,4 +11,3 @@
 Gemfile.lock
 *.so
 *.md
-*Dockerfile

data/Dockerfile

@@ -10,9 +10,9 @@ RUN bundle install
 
 COPY Rakefile ./
 COPY ext/ ./ext
-RUN rake compile
+RUN bundler exec rake compile
 
 COPY . .
-RUN rake test
+RUN bundler exec rake test
 
-CMD /bin/bash
+CMD rake test TESTOPTS='-v'

data/README.md

@@ -24,9 +24,23 @@ Or install it yourself as:
 
 TODO: Write usage instructions here
 
+### Differences with the standard matrix
+* Supported only double values
+* Can't be empty
+* Some faster
+
 ## 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.
+Fast matrix is native extension in C, so, for development you need Linux (maybe, MacOS) or Docker.
+
+After checking out the repo, run `gem install bundler -v 2.0.2`, `bundle install` and `bundler exec rake` or use `Dockerfile`.
+
+Commands:
+  + `bundler exec rake compile` - compile C part of gem;
+  + `bundler exec rake test` - run tests;
+  + `bundler exec rake test TESTOPTS='-v'` - run tests with more information (description skipped tests);
+  + `bundler exec rake` - compile and run tests.
+
 
 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).
 

data/ext/fast_matrix/c_array_opeartions.c

@@ -1,4 +1,5 @@
 #include "c_array_operations.h"
+#include "math.h"
 
 void fill_d_array(int len, double* a, double v)
 {
@@ -28,4 +29,38 @@ void add_d_arrays_to_first(int len, double* sum, const double* added)
 {
     for(int i = 0; i < len; ++i)
         sum[i] += added[i];
-}
+}
+
+void sub_d_arrays_to_result(int len, const double* dec, const double* sub, double* dif)
+{
+    for(int i = 0; i < len; ++i)
+        dif[i] = dec[i] - sub[i];
+}
+
+void sub_d_arrays_to_first(int len, double* dif, const double* sub)
+{
+    for(int i = 0; i < len; ++i)
+        dif[i] -= sub[i];
+}
+
+bool equal_d_arrays(int len, const double* A, const double* B)
+{
+    for(int i = 0; i < len; ++i)
+        if(A[i] != B[i])
+            return false;
+    return true;
+}
+
+void abs_d_array(int len, const double* A, double* B)
+{
+    for(int i = 0; i < len; ++i)
+        B[i] = fabs(A[i]);
+}
+
+bool greater_or_equal_d_array(int len, const double* A, const double* B)
+{
+    for(int i = 0; i < len; ++i)
+        if(A[i] < B[i])
+            return false;
+    return true;
+}

data/ext/fast_matrix/c_array_operations.h

@@ -1,10 +1,17 @@
 #ifndef C_ARRAY_OPERATIONS
 #define C_ARRAY_OPERATIONS
 
+#include  <stdbool.h>
+
 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);
+void sub_d_arrays_to_result(int len, const double* dec, const double* sub, double* dif);
+void sub_d_arrays_to_first(int len, double* dif, const double* sub);
+bool equal_d_arrays(int len, const double* A, const double* B);
+void abs_d_array(int len, const double* A, double* B);
+bool greater_or_equal_d_array(int len, const double* A, const double* B);
 
-#endif  /*C_ARRAY_OPERATIONS*/
+#endif  /*C_ARRAY_OPERATIONS*/

data/ext/fast_matrix/errors.c

@@ -0,0 +1,37 @@
+#include "errors.h"
+
+VALUE fm_eTypeError;
+VALUE fm_eIndexError;
+
+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(fm_eTypeError, "Value is not number");
+    return 0;
+}
+
+int raise_rb_value_to_int(VALUE v)
+{
+    if(FIXNUM_P(v))
+        return NUM2INT(v);
+
+    rb_raise(fm_eTypeError, "Index is not integer");
+    return 0;
+}
+
+void raise_check_range(int v, int min, int max)
+{
+    if(v < min || v >= max)
+        rb_raise(fm_eIndexError, "Index out of range");
+}
+
+void init_fm_errors()
+{
+    VALUE  mod = rb_define_module("FastMatrix");
+    
+    fm_eTypeError  = rb_define_class_under(mod, "TypeError",  rb_eTypeError);
+    fm_eIndexError = rb_define_class_under(mod, "IndexError", rb_eIndexError);
+}

data/ext/fast_matrix/errors.h

@@ -0,0 +1,18 @@
+#ifndef FAST_MATRIX_ERRORS_H
+#define FAST_MATRIX_ERRORS_H 1
+
+#include "ruby.h"
+
+extern VALUE fm_eTypeError;
+extern VALUE fm_eIndexError;
+
+//  convert ruby value to double or raise an error if this is not possible
+double raise_rb_value_to_double(VALUE v);
+//  convert ruby value to int or raise an error if this is not possible
+int raise_rb_value_to_int(VALUE v);
+//  check if the value is in range and raise an error if not
+void raise_check_range(int v, int min, int max);
+
+void init_fm_errors();
+
+#endif /* FAST_MATRIX_ERRORS_H */

data/ext/fast_matrix/fast_matrix.c

@@ -4,5 +4,7 @@
 
 void Init_fast_matrix()
 {
+    init_fm_errors();
     init_fm_matrix();
+    init_fm_vector();
 }

data/ext/fast_matrix/fast_matrix.h

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

data/ext/fast_matrix/matrix.c

@@ -1,9 +1,29 @@
 #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(((*(struct matrix*)data)).data);
     free(data);
 }
 
@@ -15,35 +35,10 @@ size_t matrix_size(const void* data)
 VALUE matrix_alloc(VALUE self)
 {
 	struct matrix* mtx = malloc(sizeof(struct matrix));
-
+    mtx->data = NULL;
 	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;
@@ -58,7 +53,7 @@ VALUE matrix_initialize(VALUE self, VALUE rows_count, VALUE 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");
+        rb_raise(fm_eIndexError, "Size cannot be negative or zero");
 
 	TypedData_Get_Struct(self, struct matrix, &matrix_type, data);
 
@@ -113,7 +108,6 @@ void matrix_transpose(int m, int n, const double* in, double* out)
 // 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)
@@ -126,13 +120,246 @@ void c_matrix_multiply(int n, int k, int m, const double* A, const double* B, do
             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;
@@ -141,7 +368,7 @@ VALUE matrix_multiply_mm(VALUE self, VALUE other)
 	TypedData_Get_Struct(other, struct matrix, &matrix_type, B);
 
     if(A->m != B->n)
-        rb_raise(matrix_eIndexError, "First columns differs from second rows");
+        rb_raise(fm_eIndexError, "First columns differs from second rows");
 
     int m = B->m;
     int k = A->m;
@@ -178,7 +405,11 @@ 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);
+    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)
@@ -223,15 +454,15 @@ VALUE transpose(VALUE self)
     return result;
 }
 
-VALUE add_with(VALUE self, VALUE value)
+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->m != B->m)
-        rb_raise(matrix_eIndexError, "Different sizes matrices");
+    if(A->m != B->m && A->n != B->n)
+        rb_raise(fm_eIndexError, "Different sizes matrices");
 
     int m = B->m;
     int n = A->n;
@@ -245,16 +476,15 @@ VALUE add_with(VALUE self, VALUE value)
     return result;
 }
 
-
-VALUE add_from(VALUE self, VALUE value)
+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->m != B->m)
-        rb_raise(matrix_eIndexError, "Different sizes matrices");
+    if(A->m != B->m && A->n != B->n)
+        rb_raise(fm_eIndexError, "Different sizes matrices");
 
     int m = B->m;
     int n = A->n;
@@ -264,15 +494,98 @@ VALUE add_from(VALUE self, VALUE value)
     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;
+}
+
+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_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);
 
-    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);
@@ -281,9 +594,14 @@ void init_fm_matrix()
 	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, "clone", matrix_copy, 0);
 	rb_define_method(cMatrix, "transpose", transpose, 0);
-
-	rb_define_method(cMatrix, "+", add_with, 1);
-	rb_define_method(cMatrix, "+=", add_from, 1);
-}
+	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);
+}