fast_matrix 0.1.7 → 0.1.66

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f561247c42ab2329857835462917a1a1a3ca520cb262ab89b7cc968c903f5d55
-  data.tar.gz: e606f0ca2ce438c5f0656203fb71ec70d747c8be82efc5090dd9f35fc735204c
+  metadata.gz: cfb8428a0aae303ecb09400b55429bc1d388d1f8d168f7583318b3de93cd16f0
+  data.tar.gz: b8c1bafdc23dbfcd02b801fb47f4bcfd7c865b4a545fe813327d3adaf2f41e64
 SHA512:
-  metadata.gz: c3bbb8b3e6c3d1dfaff7de547dadbc559d86318b63e2321303bf821c8b1ed3e350034798cacb47f802b86712f7b7b1bf33cce7d71a0d46bb9a3d36c1687a83fe
-  data.tar.gz: 31c9b5884b15bdcf1d82ade4090f256f30ec0dba5f1394e4b46e390ea4b5dd0df4c829823f668381253122f6cc1e9c8f19c45cfa6e7ce7bb483eec2ed51cbed1
+  metadata.gz: f7088df3f843e518dddd2dcabf92a5f8c7fe85fdd390dceb756c8e89f386e8b962e373790605246ab06bdae84be09ce09f92f9c1001a189c18d349f719161497
+  data.tar.gz: 8784f020358a09ffe6aba60391e43cead8d18990e0c0a85841c13390caad7a856aa886ac6051034f16d6fac6b6f05683703253e39ac8d7c6b249a4e4a8681810

data/.dockerignore

@@ -10,3 +10,4 @@
 *.gem
 Gemfile.lock
 *.so
+*.md

data/.travis.yml

@@ -20,5 +20,4 @@ deploy:
   gem: fast_matrix
   on:
     tags: true
-    repo: mmcs-ruby/fast_matrix
-    branch: master
+    repo: mmcs-ruby/fast_matrix

data/README.md

@@ -4,7 +4,7 @@
 
 # FastMatrix
 
-Ruby wrapper around C matrices implementation written as exercise by MMCS students.
+Ruby wrapper around C matrices implementation written as exercise by two MMCS students.
 
 ## Installation
 
@@ -22,9 +22,14 @@ Or install it yourself as:
 
     $ gem install fast_matrix
 
-## Usage and documentation
+## Usage
 
-See our [GitHub Wiki](https://github.com/mmcs-ruby/fast_matrix/wiki).
+TODO: Write usage instructions here
+
+### Differences with the standard matrix
+* Supported only double values
+* Can't be empty
+* Some faster
 
 ## Development
 

data/ext/fast_matrix/errors.c

@@ -28,16 +28,10 @@ void raise_check_range(int v, int min, int max)
         rb_raise(fm_eIndexError, "Index out of range");
 }
 
-void raise_check_rbasic(VALUE v, VALUE rBasic, const char* rbasic_name)
-{
-    if(RBASIC_CLASS(v) != rBasic)
-        rb_raise(fm_eTypeError, "Expected class %s", rbasic_name);
-}
-
 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

@@ -12,9 +12,7 @@ double raise_rb_value_to_double(VALUE v);
 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);
-//  check if the basic class of value is rBasic and raise an error if not
-void raise_check_rbasic(VALUE v, VALUE rBasic, const char* rbasic_name);
 
 void init_fm_errors();
 
-#endif /* FAST_MATRIX_ERRORS_H */
+#endif /* FAST_MATRIX_ERRORS_H */

data/ext/fast_matrix/matrix.c

@@ -125,9 +125,8 @@ 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];
-            if(d_a != 0)
-                for(int i = 0; i < m; ++i)
-                    p_c[i] += d_a * p_b[i];
+            for(int i = 0; i < m; ++i)
+                p_c[i] += d_a * p_b[i];
         }
     }
 }
@@ -191,13 +190,10 @@ void strassen_iteration(int n, int k, int m, const double* A, const double* B, d
 
 bool check_strassen(int m, int n, int k)
 {
-    return n > 2 && m > 2 && k > 2 && (double)m * (double)n * (double)k > 1000000;
+    return n > 2 && m > 2 && k > 2 && (double)m * (double)n * (double)k > 100000000;
 }
 
-//    A          B
-// [x x x]    [x x x]
-// [x x x] => [x x x]
-// [x x x]    [x x x]
+
 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)
@@ -209,41 +205,6 @@ void strassen_copy(int m, int n, const double* A, double* B, int s_a, int s_b)
     }
 }
 
-// if right = false and down = false | if right = true and down = false:       
-//        A          B               |      A           B
-//     [x x x]    [x x x]            |   [x x x]    [x x x 0]
-//     [x x x] => [x x x]            |   [x x x] => [x x x 0]
-//     [x x x]    [x x x]            |   [x x x]    [x x x 0]
-//                                   |
-// if right = false and down = true  | if right = true and down = true:       
-//        A          B               |      A           B
-//     [x x x]    [x x x]            |   [x x x]    [x x x 0]
-//     [x x x] => [x x x]            |   [x x x] => [x x x 0]
-//     [x x x]    [x x x]            |   [x x x]    [x x x 0]
-//                [0 0 0]            |              [0 0 0 0]
-void strassen_copy_with_zero(int m, int n, const double* A, double* B, int s_a, int s_b, bool right, bool down)
-{
-    double* p_B;
-    for(int i = 0; i < n; ++i)
-    {
-        const double* p_A = A + i * s_a;
-        p_B = B + i * s_b;
-        for(int j = 0; j < m; ++j)
-            p_B[j] = p_A[j];
-        if(right)
-            p_B[m] = 0;
-    }
-
-    if(down)
-    {
-        p_B = B + n * s_b;
-        for(int j = 0; j < m; ++j)
-            p_B[j] = 0;
-        if(right)
-            p_B[m] = 0;
-    }
-}
-
 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)
@@ -292,6 +253,8 @@ void recursive_strassen(int n, int k, int m, const double* A, const double* B, d
     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);
@@ -301,47 +264,55 @@ void recursive_strassen(int n, int k, int m, const double* A, const double* B, d
     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_with_zero(k1, n2, A + k * n1, termA, k, k1, false, n1 != n2);
+    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_with_zero(m2, k1, B + m1, termB, m, m1, m1 != m2, false);
+    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_with_zero(k2, n2, A + k1 + k * n1, termA, k, k1, k1 != k2, n1 != n2);
-
-    strassen_copy_with_zero(m1, k2, B + m * k1, termB, m, m1, false, k1 != k2);
+    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_with_zero(m2, k2, B + m1 + m * k1, termB, m, m1, m1 != m2, k1 != k2);
-
+    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_with_zero(k1, n2, A + k * n1, termA, k, k1, false, n1 != n2);
+    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_with_zero(k2, n1, A + k1, termA, k, k1, k1 != k2, false);
+    strassen_copy(k2, n1, A + k1, termA, k, k1);
     strassen_sub_to_first(k2, n2, termA, A + k1 + k * n1, k1, k);
     
-    strassen_copy_with_zero(m1, k2, B + k1 * m, termB, m, m1, false, k1 != k2);
+    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);
@@ -441,7 +412,7 @@ VALUE matrix_multiply(VALUE self, VALUE v)
         || RB_TYPE_P(v, T_BIGNUM))
         return matrix_multiply_mn(self, v);
     if(RBASIC_CLASS(v) == cMatrix)
-        return strassen(self, v);
+        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");
@@ -491,7 +462,6 @@ VALUE transpose(VALUE self)
 
 VALUE matrix_add_with(VALUE self, VALUE value)
 {
-    raise_check_rbasic(value, cMatrix, "matrix");
 	struct matrix* A;
     struct matrix* B;
 	TypedData_Get_Struct(self, struct matrix, &matrix_type, A);
@@ -514,7 +484,6 @@ VALUE matrix_add_with(VALUE self, VALUE value)
 
 VALUE matrix_add_from(VALUE self, VALUE value)
 {
-    raise_check_rbasic(value, cMatrix, "matrix");
 	struct matrix* A;
     struct matrix* B;
 	TypedData_Get_Struct(self, struct matrix, &matrix_type, A);
@@ -531,9 +500,9 @@ VALUE matrix_add_from(VALUE self, VALUE value)
     return self;
 }
 
+
 VALUE matrix_sub_with(VALUE self, VALUE value)
 {
-    raise_check_rbasic(value, cMatrix, "matrix");
 	struct matrix* A;
     struct matrix* B;
 	TypedData_Get_Struct(self, struct matrix, &matrix_type, A);
@@ -554,25 +523,6 @@ VALUE matrix_sub_with(VALUE self, VALUE value)
     return result;
 }
 
-VALUE matrix_sub_from(VALUE self, VALUE value)
-{
-    raise_check_rbasic(value, cMatrix, "matrix");
-	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;
-}
-
 double determinant(int n, const double* A)
 {
     double* M = malloc(n * n * sizeof(double));
@@ -609,6 +559,7 @@ 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)
@@ -617,6 +568,24 @@ VALUE matrix_determinant(VALUE self)
     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);
@@ -630,15 +599,13 @@ VALUE matrix_fill(VALUE self, VALUE value)
 
 VALUE matrix_equal(VALUE self, VALUE value)
 {
-    if(RBASIC_CLASS(value) != cMatrix)
-        return Qfalse;
 	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;
+		return Qfalse;
 
     int n = A->n;
     int m = B->m;
@@ -667,8 +634,6 @@ VALUE matrix_abs(VALUE self)
 
 VALUE matrix_greater_or_equal(VALUE self, VALUE value)
 {
-    if(RBASIC_CLASS(value) != cMatrix)
-        rb_raise(fm_eTypeError, "Expected class matrix");
 	struct matrix* A;
     struct matrix* B;
 	TypedData_Get_Struct(self, struct matrix, &matrix_type, A);
@@ -705,7 +670,7 @@ void init_fm_matrix()
 	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, "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);

data/ext/fast_matrix/vector.c

@@ -102,7 +102,6 @@ VALUE c_vector_size(VALUE self)
 
 VALUE vector_add_with(VALUE self, VALUE value)
 {
-    raise_check_rbasic(value, cVector, "vector");
 	struct vector* A;
     struct vector* B;
 	TypedData_Get_Struct(self, struct vector, &vector_type, A);
@@ -125,7 +124,6 @@ VALUE vector_add_with(VALUE self, VALUE value)
 
 VALUE vector_add_from(VALUE self, VALUE value)
 {
-    raise_check_rbasic(value, cVector, "vector");
 	struct vector* A;
     struct vector* B;
 	TypedData_Get_Struct(self, struct vector, &vector_type, A);
@@ -141,51 +139,8 @@ VALUE vector_add_from(VALUE self, VALUE value)
     return self;
 }
 
-VALUE vector_sub_with(VALUE self, VALUE value)
-{
-    raise_check_rbasic(value, cVector, "vector");
-	struct vector* A;
-    struct vector* B;
-	TypedData_Get_Struct(self, struct vector, &vector_type, A);
-	TypedData_Get_Struct(value, struct vector, &vector_type, B);
-
-    if(A->n != B->n)
-        rb_raise(fm_eIndexError, "Different sizes matrices");
-
-    int n = A->n;
-
-    struct vector* C;
-    VALUE result = TypedData_Make_Struct(cVector, struct vector, &vector_type, C);
-
-    c_vector_init(C, n);
-    sub_d_arrays_to_result(n, A->data, B->data, C->data);
-
-    return result;
-}
-
-
-VALUE vector_sub_from(VALUE self, VALUE value)
-{
-    raise_check_rbasic(value, cVector, "vector");
-	struct vector* A;
-    struct vector* B;
-	TypedData_Get_Struct(self, struct vector, &vector_type, A);
-	TypedData_Get_Struct(value, struct vector, &vector_type, B);
-
-    if(A->n != B->n)
-        rb_raise(fm_eIndexError, "Different sizes matrices");
-
-    int n = A->n;
-
-    sub_d_arrays_to_first(n, A->data, B->data);
-
-    return self;
-}
-
 VALUE vector_equal(VALUE self, VALUE value)
 {
-    if(RBASIC_CLASS(value) != cVector)
-        return Qfalse;
 	struct vector* A;
     struct vector* B;
 	TypedData_Get_Struct(self, struct vector, &vector_type, A);
@@ -316,8 +271,6 @@ void init_fm_vector()
 	rb_define_method(cVector, "size", c_vector_size, 0);
 	rb_define_method(cVector, "+", vector_add_with, 1);
 	rb_define_method(cVector, "+=", vector_add_from, 1);
-	rb_define_method(cVector, "-", vector_sub_with, 1);
-	rb_define_method(cVector, "-=", vector_sub_from, 1);
 	rb_define_method(cVector, "eql?", vector_equal, 1);
 	rb_define_method(cVector, "clone", vector_copy, 0);
 	rb_define_method(cVector, "*", vector_multiply, 1);

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

data/lib/fast_matrix/version.rb

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

data/lib/matrix/matrix.rb

@@ -19,25 +19,13 @@ module FastMatrix
     alias element []
     alias component []
 
-    def collect
-      collected_rows = []
-      rows.each do |i|
-        collected_rows.push(yield i)
-      end
-      collected_rows
-    end
-
-    #
-    # Overrides Object#to_s
-    #
     def to_s
-      "#{self.class}[#{collect do |row|
-        '[' + row.join(', ') + ']'
-      end.join(', ')}]"
+      convert.to_s
     end
 
-    alias to_str to_s
-    alias inspect to_str
+    def inspect
+      convert.inspect
+    end
 
     #
     # Create fast matrix from standard matrix
@@ -52,42 +40,14 @@ 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(&block)
-      raise NotSupportedError unless block_given?
-
-      each_with_index { |elem, _, _| block.call(elem) }
-      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|
@@ -116,19 +76,5 @@ 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/vector.rb

@@ -21,32 +21,12 @@ 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fast_matrix
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.66
 platform: ruby
 authors:
 - mmcs_ruby
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-11-03 00:00:00.000000000 Z
+date: 2019-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -117,11 +117,11 @@ files:
 - lib/scalar.rb
 - lib/vector/constructors.rb
 - lib/vector/vector.rb
-homepage: https://github.com/mmcs-ruby/fast_matrix/wiki
+homepage: https://github.com/mmcs-ruby/fast_matrix
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/mmcs-ruby/fast_matrix/wiki
+  homepage_uri: https://github.com/mmcs-ruby/fast_matrix
   source_code_uri: https://github.com/mmcs-ruby/fast_matrix
 post_install_message: 
 rdoc_options: []