matrix_boost 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b309404421f2759c33ecc81ed7fcd0a97d4523189dbd0cddae4605708b1098cb
-  data.tar.gz: fa48071d459c9a49faf9f3485e8501878e3bf0b75ad9e64539e6291265986acc
+  metadata.gz: edf1ea7cf2375607d1680ad931b9da4740bd94ed4751bb11076c7f76f8eb3466
+  data.tar.gz: 8b8fde75f0be426b15b1fb44493bc5cb8373985a718edb429686d558d7e63535
 SHA512:
-  metadata.gz: d07a2ab0fe8daf2da74e8ca9420c29166d8df42afdce783b601d3235d362eb55e7cbd587b3b904c26f9c1dcbfc378c386bd4857bf93ec2ebbedb551ad93921fd
-  data.tar.gz: 8245b8b399a23e7b0698df9485e63e2ae3e3ac12209732e615cfe74c39145d0d972a8c935fd294004684d106d93418d85978bd8aec8dc2398b83d4dd41292238
+  metadata.gz: b40d23ee4416f3f411cf9e68f597f468cfd8f60dec26a32053b108e60edb3be7a1c338cf7afb9a52fdc32e36b68798d39410daf7e99c746eb800d000cab0b7f1
+  data.tar.gz: f287eabc86984559b619340f54a6ac044223b680e86502ba4b3cde448c755dcd00ae2965fc158851f91d7f410e6e8c5860127048667ea72ce7b49e116adb4f2d

data/.gitignore

@@ -10,3 +10,4 @@ Gemfile.lock
 ext/*.o
 ext/*.bundle
 ext/Makefile
+*.gem

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [v0.2.0](https://github.com/Bajena/matrix_boost/tree/v0.2.0) (2020-04-18)
+
+[Full Changelog](https://github.com/Bajena/matrix_boost/compare/v0.1.1...v0.2.0)
+
+**Closed issues:**
+
+- Add inversion boost [\#1](https://github.com/Bajena/matrix_boost/issues/1)
+
+**Merged pull requests:**
+
+- Add inversion [\#2](https://github.com/Bajena/matrix_boost/pull/2) ([Bajena](https://github.com/Bajena))
+
+## [v0.1.1](https://github.com/Bajena/matrix_boost/tree/v0.1.1) (2020-04-12)
+
+[Full Changelog](https://github.com/Bajena/matrix_boost/compare/v0.1.0...v0.1.1)
+
 ## [v0.1.0](https://github.com/Bajena/matrix_boost/tree/v0.1.0) (2020-04-12)
 
 [Full Changelog](https://github.com/Bajena/matrix_boost/compare/8f26eddc7e648c0c68375b52b736535126bfd47f...v0.1.0)

data/README.md

@@ -8,21 +8,34 @@ from Ruby's [https://ruby-doc.org/stdlib-2.5.1/libdoc/matrix/rdoc/Matrix.html](M
 ### Performance comparison
 
 ```bash
-irb(main):007:0> MatrixBoost.benchmark(dim: 3, n: 10000000)
+→ bin/rake benchmark_multiply; bin/rake benchmark_inverse
+Benchmark multiplication (dim = 4, n = 1000000)...
                                                     user     system      total        real
-Ruby matrix multiply:                          81.385777   0.190162  81.575939 ( 81.751942)
-C matrix multiply:                             47.041961   0.081723  47.123684 ( 47.206611)
-Ruby matrix multiply after monkey patch:       50.903808   0.222949  51.126757 ( 51.351058
+Ruby matrix multiply:                          22.627594   0.180447  22.808041 ( 23.473300)
+C matrix multiply:                             12.393963   0.124988  12.518951 ( 13.102763)
+Ruby matrix multiply after monkey patch:       11.493074   0.073740  11.566814 ( 11.645836)
+>Ruby slower (%):                               1.825695   1.443715        NaN (  1.791477)
+
+Benchmark inversion (dim = 4, n = 1000000)...
+                                                    user     system      total        real
+Ruby matrix inverse:                           26.191386   0.067096  26.258482 ( 26.328944)
+C matrix inverse:                               4.911581   0.005300   4.916881 (  4.920316)
+Ruby matrix inverse after monkey patch:         5.180995   0.003944   5.184939 (  5.187873)
+>Ruby slower (%):                               5.332577  12.659623        NaN (  5.351068)
 ```
 
-as you can see Ruby's Matrix implementation is ~67% slower than the same operation
+- Ruby's multiplication of 4-dimensional martices is **~79%** slower than the same operation
+implemented in a C extension 🎉.
+- Ruby's inversion of 4-dimensional matrices is **~435%** slower than the same operation
 implemented in a C extension 🎉.
 
 ### Matrix class core extension
 Even though this gem was created mainly for learning how to use C extensions in Ruby
 you should still be able to use it in your production code.
 
-You can either use `MatrixBoost.multiply(m1, m2)` or replace the original methods
+You can install the gem by adding `gem "matrix_boost"` to your gemfile.
+
+Then you can either use `MatrixBoost.multiply(m1, m2)` or `MatrixBoost.invert(m)` or replace the original methods
 from `Matrix` by calling `MatrixBoost.apply_core_extensions`.
 
 ### How do I play around?

data/Rakefile

@@ -17,6 +17,55 @@ task :compile do
   puts "Done"
 end
 
+task :benchmark_multiply do
+  require "matrix_boost"
+
+  dim = 4
+  n = 10000
+
+  m1 = Matrix.build(dim) { rand }
+  m2 = Matrix.build(dim) { rand }
+
+  puts "Benchmark multiplication (dim = #{dim}, n = #{n})..."
+
+  Benchmark.benchmark(Benchmark::CAPTION, 45, Benchmark::FORMAT, ">Ruby slower (%):") do |x|
+    r = x.report("Ruby matrix multiply:") { n.times { m1 * m2 } }
+    c = x.report("C matrix multiply:") { n.times { MatrixBoost.multiply(m1, m2) } }
+
+    MatrixBoost.apply_core_extensions
+    x.report("Ruby matrix multiply after monkey patch:") { n.times { m1 * m2 } }
+
+    [r / c]
+  end
+
+  puts "Done"
+  puts ""
+end
+
+task :benchmark_inverse do
+  require "matrix_boost"
+
+  dim = 4
+  n = 10000
+
+  puts "Benchmark inversion (dim = #{dim}, n = #{n})..."
+
+  m = Matrix.build(dim) { rand }
+
+  Benchmark.benchmark(Benchmark::CAPTION, 45, Benchmark::FORMAT, ">Ruby slower (%):") do |x|
+    r = x.report("Ruby matrix inverse:") { n.times { m.inverse } }
+    c = x.report("C matrix inverse:") { n.times { MatrixBoost.invert(m) } }
+
+    MatrixBoost.apply_core_extensions
+    x.report("Ruby matrix inverse after monkey patch:") { n.times { m.inverse } }
+
+    [r / c]
+  end
+
+  puts "Done"
+  puts ""
+end
+
 GitHubChangelogGenerator::RakeTask.new :changelog do |config|
   config.user = "Bajena"
   config.project = "matrix_boost"

data/ext/extension.c

@@ -29,7 +29,7 @@ Matrix* rb_array_to_matrix(VALUE a) {
   Check_Type(first_row, T_ARRAY);
   long columns = RARRAY_LEN(first_row);
 
-  Matrix *matrix = constructor(rows, columns);
+  Matrix *matrix = matrix_constructor(rows, columns);
   int row;
   int column;
 
@@ -51,14 +51,31 @@ static VALUE mul_matrix(VALUE self, VALUE m1, VALUE m2) {
   Matrix *m1c = rb_array_to_matrix(m1);
   Matrix *m2c = rb_array_to_matrix(m2);
 
-  Matrix *multiplied = multiply(m1c, m2c);
+  Matrix *multiplied = matrix_multiply(m1c, m2c);
 
-  destroy_matrix(m1c);
-  destroy_matrix(m2c);
+  matrix_destroy(m1c);
+  matrix_destroy(m2c);
 
   if (multiplied) {
     VALUE result = matrix_to_rb_array(multiplied);
-    destroy_matrix(multiplied);
+    matrix_destroy(multiplied);
+    return result;
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE inv_matrix(VALUE self, VALUE m) {
+  Check_Type(m, T_ARRAY);
+
+  Matrix *mc = rb_array_to_matrix(m);
+  Matrix *inverted = matrix_invert(mc);
+
+  matrix_destroy(mc);
+
+  if (inverted) {
+    VALUE result = matrix_to_rb_array(inverted);
+    matrix_destroy(inverted);
     return result;
   } else {
     return Qnil;
@@ -69,4 +86,5 @@ void Init_extension(void) {
   VALUE MatrixBoost = rb_define_module("MatrixBoost");
   VALUE NativeHelpers = rb_define_class_under(MatrixBoost, "NativeHelpers", rb_cObject);
   rb_define_singleton_method(NativeHelpers, "mul_matrix", mul_matrix, 2);
+  rb_define_singleton_method(NativeHelpers, "inv_matrix", inv_matrix, 1);
 }

data/ext/matrices.c

@@ -21,10 +21,11 @@ rows    |
 the matrix is an array of array pointers where each array pointer corresponds to a vector
 */
 
-static double vector_multiply(double *col, double *row, int length);
+static double matrix_vector_multiply(double *col, double *row, int length);
+static int matrix_row_scalar_multiply(Matrix *m, int row, float factor);
 
 /* make a zero matrix of given dimensions */
-Matrix *constructor(int r, int c){
+Matrix *matrix_constructor(int r, int c){
   unsigned int i;
   Matrix *m;
   if(r <= 0 || c <= 0){
@@ -41,7 +42,7 @@ Matrix *constructor(int r, int c){
 }
 
 /* free memory associated with the matrix  */
-int destroy_matrix(Matrix *m){
+int matrix_destroy(Matrix *m){
   unsigned int i;
   if(m == NULL)
     return FAIL;
@@ -52,8 +53,19 @@ int destroy_matrix(Matrix *m){
   return SUCC;
 }
 
+/* enter 1s along the main diagonal */
+Matrix *matrix_identity(int length){
+  unsigned int i, j;
+  Matrix *m;
+  m = matrix_constructor(length, length);
+  for(i = 0; i < length; i++){
+    j = i;
+    (m->numbers[i])[j] = 1;
+  }
+  return m;
+}
 /* print the matrix  */
-int print(Matrix *m){
+int matrix_print(Matrix *m){
   unsigned int i, j;
   if(m == NULL)
     return FAIL;
@@ -66,12 +78,12 @@ int print(Matrix *m){
   return SUCC;
 }
 
-Matrix *transpose(Matrix *m){
+Matrix *matrix_transpose(Matrix *m){
   Matrix *trans;
   unsigned int i, j;
   if(m == NULL)
     return NULL;
-  trans = constructor(m->columns, m->rows);
+  trans = matrix_constructor(m->columns, m->rows);
   for(i = 0; i < trans->columns; i++){
     for(j = 0; j < trans->rows; j++)
       trans->numbers[i][j] = m->numbers[j][i];
@@ -80,26 +92,117 @@ Matrix *transpose(Matrix *m){
 }
 
 /* m1 x m2  */
-Matrix *multiply(Matrix *m1, Matrix *m2){
+Matrix *matrix_multiply(Matrix *m1, Matrix *m2){
   Matrix *product, *trans;
   unsigned int i, j;
   if(m1 == NULL || m2 == NULL)
     return NULL;
   if(m1->columns != m2->rows)
     return NULL;
-  trans = transpose(m1);
-  product = constructor(m1->rows, m2->columns);
+  trans = matrix_transpose(m1);
+  product = matrix_constructor(m1->rows, m2->columns);
   for(i = 0; i < product->columns; i++){
     for(j = 0; j < product->rows; j++){
-      product->numbers[i][j] = vector_multiply(trans->numbers[j], m2->numbers[i], m2->rows);
+      product->numbers[i][j] = matrix_vector_multiply(trans->numbers[j], m2->numbers[i], m2->rows);
     }
   }
-  destroy_matrix(trans);
+  matrix_destroy(trans);
   return product;
 }
 
+/* matrix m will become the matrix_identity so the caller must save their matrix themselves  */
+Matrix *matrix_invert(Matrix *m){
+  Matrix *invert;
+  unsigned int i, j, l;
+  double factor;
+  if(m == NULL)
+    return NULL;
+  if((m)->columns != (m)->rows)
+    return NULL;
+  invert = matrix_identity((m)->rows);
+
+  /* matrix_reduce each of the rows to get a lower triangle */
+  for(i = 0; i < (m)->columns; i++){
+    for(j = i + 1; j < (m)->rows; j++){
+      if((m)->numbers[i][i] == 0){
+        for(l=i+1; l < m->rows; l++){
+          if(m->numbers[l][l] != 0){
+            matrix_row_swap(m, i, l);
+            break;
+          }
+        }
+        continue;
+      }
+      factor = (m)->numbers[i][j]/((m)->numbers[i][i]);
+      matrix_reduce(invert, i, j, factor);
+      matrix_reduce((m), i, j, factor);
+    }
+  }
+  /* now finish the upper triangle  */
+  for(i = (m)->columns - 1; i > 0; i--){
+    for(j = i-1; j>=0; j--){
+      if((m)->numbers[i][i] == 0)
+        continue;
+      if(j == -1)
+        break;
+      factor = (m)->numbers[i][j]/((m)->numbers[i][i]);
+      matrix_reduce(invert, i, j, factor);
+      matrix_reduce((m), i, j, factor);
+    }
+  }
+  /* scale everything to 1 */
+  for(i = 0; i < (m)->columns; i++){
+    if((m)->numbers[i][i]==0)
+      continue;
+    factor = 1/((m)->numbers[i][i]);
+    matrix_row_scalar_multiply(invert, i, factor);
+    matrix_row_scalar_multiply((m), i, factor);
+  }
+  return invert;
+}
+
+int matrix_row_swap(Matrix *m, int a, int b){
+  double temp;
+  unsigned int i;
+  if(m == NULL)
+    return FAIL;
+  if(m->rows <= a || m->rows <= b)
+    return FAIL;
+  for(i = 0; i < m->columns; i++){
+    temp = m->numbers[i][a];
+    m->numbers[i][a] = m->numbers[i][b];
+    m->numbers[i][b] = temp;
+  }
+  return SUCC;
+}
+
+static int matrix_row_scalar_multiply(Matrix *m, int row, float factor){
+  int i;
+  if(m == NULL)
+    return FAIL;
+  if(m->rows <= row)
+    return FAIL;
+  for(i = 0; i < m->columns; i++)
+    m->numbers[i][row] *= factor;
+  return SUCC;
+}
+
+/* matrix_reduce row b by factor*a  */
+int matrix_reduce(Matrix *m, int a, int b, float factor){
+  int i;
+  if(m == NULL)
+    return FAIL;
+  if(m->rows < a || m->rows < b)
+    return FAIL;
+  for(i = 0; i < m->columns; i++){
+    m->numbers[i][b]  -= m->numbers[i][a]*factor;
+  }
+
+  return SUCC;
+}
+
 /* v1 x v2  -- simply a helper function -- computes dot product between two vectors*/
-static double vector_multiply(double *col, double *row, int length){
+static double matrix_vector_multiply(double *col, double *row, int length){
   double sum;
   unsigned int i;
   sum = 0;

data/ext/matrices.h

@@ -4,6 +4,7 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+
 /* current representation of a matrix in my mind  */
 typedef struct Matrix{
   int rows;
@@ -11,11 +12,15 @@ typedef struct Matrix{
   double **numbers;
 } Matrix;
 
-Matrix *constructor(int r, int c);
-int destroy_matrix(Matrix *m);
-int print(Matrix *m);
-Matrix *transpose(Matrix *m);
-Matrix *multiply(Matrix *m1, Matrix *m2);
+Matrix *matrix_constructor(int r, int c);
+Matrix *matrix_identity(int length);
+int matrix_destroy(Matrix *m);
+int matrix_print(Matrix *m);
+Matrix *matrix_transpose(Matrix *m);
+Matrix *matrix_multiply(Matrix *m1, Matrix *m2);
+Matrix *matrix_invert(Matrix *m);
+int matrix_reduce(Matrix *m, int a, int b, float factor);
+int matrix_row_swap(Matrix *m, int a, int b);
 
 #ifdef __cplusplus
 }

data/lib/matrix_boost.rb

@@ -11,26 +11,17 @@ module MatrixBoost
       Matrix[*NativeHelpers.mul_matrix(m1.to_a, m2.to_a)]
     end
 
-    def benchmark(dim: 3, n: 100000)
-      m1 = Matrix[[1, 2, 3], [4, 5, 6]]
-      m2 = Matrix[[9,8],[7,6],[5,4]]
-
-      m1 = Matrix.build(dim) { rand }
-      m2 = Matrix.build(dim) { rand }
-
-      Benchmark.benchmark(Benchmark::CAPTION, 45, Benchmark::FORMAT) do |x|
-        x.report("Ruby matrix multiply:") { n.times { m1 * m2 } }
-        x.report("C matrix multiply:") { n.times { multiply(m1, m2) } }
-
-        apply_core_extensions
-        x.report("Ruby matrix multiply after monkey patch:") { n.times { m1 * m2 } }
-      end
+    # @param m [Matrix] Stdlib Matrix instance
+    # @return [Matrix] Inverted matrix
+    def invert(m)
+      Matrix[*NativeHelpers.inv_matrix(m.to_a)]
     end
 
     def apply_core_extensions
       require "matrix_boost/core_extensions"
 
       Matrix.prepend MatrixBoost::CoreExtensions::Multiply
+      Matrix.prepend MatrixBoost::CoreExtensions::Inverse
     end
   end
 end

data/lib/matrix_boost/core_extensions.rb

@@ -15,5 +15,14 @@ module MatrixBoost
         end
       end
     end
+
+    module Inverse
+      # Overrides https://github.com/ruby/matrix/blob/master/lib/matrix.rb#L1175
+      def inverse
+        raise ErrDimensionMismatch unless square?
+
+        MatrixBoost.invert(self)
+      end
+    end
   end
 end

data/lib/matrix_boost/version.rb

@@ -1,3 +1,3 @@
 module MatrixBoost
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: matrix_boost
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Jan Bajena
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-12 00:00:00.000000000 Z
+date: 2020-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake