Matrix Ruby Wrappers

ext/symengine/CMakeLists.txt

@@ -10,6 +10,7 @@ set(RUBY_WRAPPER_SRC
     ruby_function.c
     ruby_ntheory.c
     ruby_utils.c
+    ruby_matrix.c
     symengine_utils.c
     symengine.c
     )

ext/symengine/ruby_matrix.c

@@ -0,0 +1,123 @@
+#include "ruby_matrix.h"
+
+void cmatrix_dense_free(void *ptr)
+{
+    CDenseMatrix *mat_ptr = ptr;
+    dense_matrix_free(mat_ptr);
+}
+
+VALUE cmatrix_dense_alloc(VALUE klass)
+{
+    CDenseMatrix *mat_ptr = dense_matrix_new();
+    return Data_Wrap_Struct(klass, NULL, cmatrix_dense_free, mat_ptr);
+}
+
+VALUE cmatrix_to_str(VALUE self)
+{
+    CDenseMatrix *this;
+    char *str_ptr;
+    VALUE result;
+
+    Data_Get_Struct(self, CDenseMatrix, this);
+
+    str_ptr = matrix_str(this);
+    result = rb_str_new_cstr(str_ptr);
+    basic_str_free(str_ptr);
+
+    return result;
+}
+
+
+VALUE cmatrix_dense_init(VALUE self, VALUE args)
+{
+    int argc = RARRAY_LEN(args);
+    CDenseMatrix *this;
+    Data_Get_Struct(self, CDenseMatrix, this);
+
+    if (argc == 0) {
+
+    // SymEngine::DenseMatrix()
+        dense_matrix(this);
+
+    } else if (argc == 1) {
+    // SymEngine::DenseMatrix(SymEngine::DenseMatrix) OR
+    // SymEngine::DenseMatrix(NMatrix) OR
+    // SymEngine::DenseMatrix(Array)
+
+        VALUE operand = rb_ary_shift(args);
+        char *s = rb_obj_classname(operand);
+
+        if(strcmp(s, "SymEngine::DenseMatrix") == 0) {
+
+        // SymEngine::DenseMatrix(SymEngine::DenseMatrix)
+            CDenseMatrix *temp;
+            Data_Get_Struct(operand, CDenseMatrix, temp);
+            dense_matrix_set(this, temp);
+
+        } else if(strcmp(s, "NMatrix") == 0) {
+
+        // SymEngine::DenseMatrix(NMatrix)
+            rb_raise(rb_eTypeError, "TODO");
+
+        } else if(strcmp(s, "Array") == 0) {
+
+        // SymEngine::DenseMatrix(Array)
+            int counter = 0;
+
+            int rows = RARRAY_LEN(operand);
+            int cols = -1;
+            CVecBasic *cargs = vecbasic_new();
+            basic x;
+            basic_new_stack(x);
+            int i;
+            for (i = 0; i < rows; i++) {
+                int j;
+                VALUE row = rb_ary_shift(operand);
+                if ( cols == -1 ) {
+                    cols = RARRAY_LEN(row); 
+                // Checking all rows for same col length
+                } else if (cols != RARRAY_LEN(row)) {
+                    rb_raise(rb_eTypeError, "2D Array's rows contain different column counts");
+                }
+
+                for(j = 0; j < cols; j++) {
+                    sympify(rb_ary_shift(row), x);
+                    vecbasic_push_back(cargs, x);
+                    counter++;
+                }
+            }
+            dense_matrix_set_vec(this, rows, cols, cargs);
+
+            basic_free_stack(x);
+            vecbasic_free(cargs);
+
+        } else {
+            rb_raise(rb_eTypeError, "Invalid Arguments. No Arguments, a single SymEngine::DenseMatrix, a single NMatrix, a single Array or two Numerics expected.");
+        } 
+
+    } else if (argc == 2) {
+
+    // SymEngine::DenseMatrix(no_rows, no_cols)
+        VALUE val1 = rb_ary_shift(args);
+        VALUE val2 = rb_ary_shift(args);
+
+        if((TYPE(val1) == T_FIXNUM || TYPE(val1) == T_BIGNUM) 
+            && (TYPE(val2) == T_FIXNUM || TYPE(val2) == T_BIGNUM) ) {
+
+            unsigned long int rows = NUM2ULONG(val1);
+            unsigned long int cols = NUM2ULONG(val2);
+            dense_matrix_rows_cols(this, rows, cols);
+
+        } else {
+
+            rb_raise(rb_eTypeError, "Invalid Arguments. No Arguments, a single SymEngine::DenseMatrix, a single NMatrix, a single Array or two Numerics expected.");
+
+        }
+    } else {
+
+        rb_raise(rb_eTypeError, "Invalid Arguments. No Arguments, a single SymEngine::DenseMatrix, a single NMatrix, a single Array or two Numerics expected.");
+
+    }
+
+    return self;
+}

ext/symengine/ruby_matrix.h

@@ -0,0 +1,12 @@
+#ifndef RUBY_MATRIX_H_
+#define RUBY_MATRIX_H_
+
+#include <ruby.h>
+#include <symengine/cwrapper.h>
+
+void cmatrix_dense_free(void *ptr);
+VALUE cmatrix_dense_alloc(VALUE klass);
+VALUE cmatrix_dense_init(VALUE self, VALUE args);
+VALUE cmatrix_to_str(VALUE self);
+
+#endif // RUBY_MATRIX_H_

ext/symengine/symengine.c

@@ -10,6 +10,7 @@
 #include "ruby_function.h"
 #include "ruby_ntheory.h"
 #include "ruby_utils.h"
+#include "ruby_matrix.h"
 #include "symengine_utils.h"
 #include "symengine.h"
 
@@ -224,6 +225,18 @@ void Init_symengine()
     rb_define_module_function(m_symengine, "fibonacci", cntheory_fibonacci, 1);
     rb_define_module_function(m_symengine, "lucas", cntheory_lucas, 1);
     rb_define_module_function(m_symengine, "binomial", cntheory_binomial, 2);
+
+    // MatrixBase Class
+    c_matrix_base = rb_define_class_under(m_symengine, "MatrixBase", rb_cObject);
+
+    // DenseMatrix and SparseMatrix Classes
+    c_dense_matrix = rb_define_class_under(m_symengine, "DenseMatrix", c_matrix_base);
+    c_sparse_matrix = rb_define_class_under(m_symengine, "SparseMatrix", c_matrix_base);
+
+    // DenseMatrix Methods
+    rb_define_alloc_func(c_dense_matrix, cmatrix_dense_alloc);
+    rb_define_method(c_dense_matrix, "initialize", cmatrix_dense_init, -2);
+    rb_define_method(c_dense_matrix, "to_s", cmatrix_to_str, 0);
 
     symengine_print_stack_on_segfault();
 }

ext/symengine/symengine.h

@@ -59,5 +59,8 @@ VALUE c_atanh;
 VALUE c_acsch;
 VALUE c_asech;
 VALUE c_acoth;
+VALUE c_matrix_base;
+VALUE c_dense_matrix;
+VALUE c_sparse_matrix;
 
 #endif // SYMENGINE_H_

lib/symengine.rb

@@ -40,3 +40,4 @@ def Function(n)
 require 'symengine/complex'
 require 'symengine/complex_double'
 require 'symengine/undef_function'
+require 'symengine/matrix_base'

lib/symengine/matrix_base.rb

@@ -0,0 +1,7 @@
+module SymEngine
+  class MatrixBase
+    def inspect
+      "#<#{self.class}(#{to_s})>"
+    end
+  end
+end