fast_matrix 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b595a00ec07bf1d240037d16e3691d99f02b1313f0601ddc384c1bbc46378511
-  data.tar.gz: 0bc5cd22534b4add7364cc0531a438e5b909ab157c4778af1aaa3eb13e0afe9c
+  metadata.gz: f561247c42ab2329857835462917a1a1a3ca520cb262ab89b7cc968c903f5d55
+  data.tar.gz: e606f0ca2ce438c5f0656203fb71ec70d747c8be82efc5090dd9f35fc735204c
 SHA512:
-  metadata.gz: 1eebf62db5b0214d6a04414cff95b6179bcfea2fc972397da325bb8a4efd871768711a9989572d18f7eb6ca1f51da7b0de84d3c1aa56547703ed4e0d72c4958b
-  data.tar.gz: 823754bfaf70c9ec3b1dafe6ba409ec954e332a7d48f66ef8e9327bbddcd9288a8d4dc55f053c990279f1ad17455384d92a68bd7b214e074dbd9f295b98f3019
+  metadata.gz: c3bbb8b3e6c3d1dfaff7de547dadbc559d86318b63e2321303bf821c8b1ed3e350034798cacb47f802b86712f7b7b1bf33cce7d71a0d46bb9a3d36c1687a83fe
+  data.tar.gz: 31c9b5884b15bdcf1d82ade4090f256f30ec0dba5f1394e4b46e390ea4b5dd0df4c829823f668381253122f6cc1e9c8f19c45cfa6e7ce7bb483eec2ed51cbed1

data/.dockerignore

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

data/.travis.yml

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

data/README.md

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

data/ext/fast_matrix/errors.c

@@ -28,10 +28,16 @@ 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,7 +12,9 @@ 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,8 +125,9 @@ 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];
+            if(d_a != 0)
+                for(int i = 0; i < m; ++i)
+                    p_c[i] += d_a * p_b[i];
         }
     }
 }
@@ -190,10 +191,13 @@ 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 > 100000000;
+    return n > 2 && m > 2 && k > 2 && (double)m * (double)n * (double)k > 1000000;
 }
 
-
+//    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)
@@ -205,6 +209,41 @@ 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)
@@ -253,8 +292,6 @@ 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);
@@ -264,55 +301,47 @@ 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(k1, n2, A + k * n1, termA, k, k1);
+    strassen_copy_with_zero(k1, n2, A + k * n1, termA, k, k1, false, n1 != n2);
     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_copy_with_zero(m2, k1, B + m1, termB, m, m1, m1 != m2, false);
     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_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_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);
-    
+    strassen_copy_with_zero(m2, k2, B + m1 + m * k1, termB, m, m1, m1 != m2, k1 != k2);
+
     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_copy_with_zero(k1, n2, A + k * n1, termA, k, k1, false, n1 != n2);
     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_copy_with_zero(k2, n1, A + k1, termA, k, k1, k1 != k2, false);
     strassen_sub_to_first(k2, n2, termA, A + k1 + k * n1, k1, k);
     
-    strassen_copy(m1, k2, B + k1 * m, termB, m, m1);
+    strassen_copy_with_zero(m1, k2, B + k1 * m, termB, m, m1, false, k1 != k2);
     strassen_sum_to_first(m2, k2, termB, B + m1 + m * k1, m1, m);
     
     recursive_strassen(n1, k1, m1, termA, termB, P7);
@@ -412,7 +441,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 matrix_multiply_mm(self, v);
+        return strassen(self, v);
     if(RBASIC_CLASS(v) == cVector);
         return matrix_multiply_mv(self, v);
     rb_raise(fm_eTypeError, "Invalid klass for multiply");
@@ -462,6 +491,7 @@ 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);
@@ -484,6 +514,7 @@ 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);
@@ -500,9 +531,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);
@@ -523,6 +554,25 @@ 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));
@@ -559,7 +609,6 @@ 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)
@@ -568,24 +617,6 @@ 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);
@@ -599,13 +630,15 @@ 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;
@@ -634,6 +667,8 @@ 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);
@@ -670,7 +705,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,6 +102,7 @@ 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);
@@ -124,6 +125,7 @@ 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);
@@ -139,8 +141,51 @@ 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);
@@ -271,6 +316,8 @@ 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"
+  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.6'
+  VERSION = '0.1.7'
 end

data/lib/matrix/matrix.rb

@@ -19,14 +19,26 @@ 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
+
     #
     # Create fast matrix from standard matrix
     #
@@ -40,14 +52,42 @@ 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|
@@ -76,5 +116,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/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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fast_matrix
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - mmcs_ruby
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-10-29 00:00:00.000000000 Z
+date: 2019-11-03 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
+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: []