ruby-eigen 0.0.11.pre1 → 0.0.11.pre2

data/ext/eigen/rubyeigen_algo.h

@@ -0,0 +1,13 @@
+namespace RubyEigen {
+  typedef FullPivLU<MatrixXd> FullPivLUDouble;
+  typedef FullPivLU<MatrixXcd> FullPivLUComplex;
+  typedef PartialPivLU<MatrixXd> PartialPivLUDouble;
+  typedef FullPivHouseholderQR<MatrixXd> FullPivHouseholderQRDouble;
+  typedef FullPivHouseholderQR<MatrixXcd> FullPivHouseholderQRComplex;
+  typedef JacobiSVD<MatrixXd> JacobiSVDDouble;
+  typedef JacobiSVD<MatrixXcd> JacobiSVDComplex;
+  typedef LDLT<MatrixXd>  LDLTDouble;
+  typedef LDLT<MatrixXcd> LDLTComplex;
+  typedef LLT<MatrixXd>   LLTDouble;
+  typedef LLT<MatrixXcd>  LLTComplex;
+};

data/ext/eigen/rubyeigen_algo_base.h

@@ -0,0 +1,7 @@
+namespace RubyEigen {
+  typedef SparseQR<RubyEigen::SpMatrixDouble, COLAMDOrdering<int> > SparseQRDouble;
+  typedef SparseQR<RubyEigen::SpMatrixFloat, COLAMDOrdering<int> > SparseQRFloat;
+
+  typedef SparseLU<RubyEigen::SpMatrixDouble, COLAMDOrdering<int> > SparseLUDouble;
+  typedef SparseLU<RubyEigen::SpMatrixFloat, COLAMDOrdering<int> > SparseLUFloat;
+};

data/ext/eigen/rubyeigen_base.h

@@ -0,0 +1,34 @@
+/* To avoid contaminating Eigen namespace, we use RubyEigen instead of Eigen. */
+namespace RubyEigen {
+
+  typedef RubyEigen::Matrix<double, RubyEigen::Dynamic, RubyEigen::Dynamic> MatrixDouble;
+  typedef RubyEigen::Matrix<float, RubyEigen::Dynamic, RubyEigen::Dynamic> MatrixFloat;
+  typedef RubyEigen::Matrix<std::complex<double>, RubyEigen::Dynamic, RubyEigen::Dynamic> MatrixComplex;
+  typedef RubyEigen::Matrix<std::complex<float>, RubyEigen::Dynamic, RubyEigen::Dynamic> MatrixComplexFloat;
+
+  typedef RubyEigen::Array<double, RubyEigen::Dynamic, RubyEigen::Dynamic> ArrayXXd;
+ 
+  /*
+     By redefining VectorXd and VectorXcd in SWIG scope, SWIG can interpret what the templates are.
+     The following templates appear in some decomposition classes.
+  */
+  typedef RubyEigen::Matrix<RubyEigen::MatrixDouble::Scalar, RubyEigen::Dynamic, 1> VectorXd;
+  typedef RubyEigen::Matrix<RubyEigen::MatrixComplex::Scalar, RubyEigen::Dynamic, 1> VectorXcd;
+  typedef RubyEigen::Matrix<RubyEigen::MatrixXi::Scalar, RubyEigen::Dynamic, 1> VectorXi;
+
+  typedef RubyEigen::Block<RubyEigen::MatrixDouble> MatrixDoubleRef;
+  typedef RubyEigen::Block<RubyEigen::MatrixXcd> MatrixComplexRef;
+
+  typedef Matrix<bool, Dynamic, Dynamic> MatrixBool;
+  typedef Matrix<bool, Dynamic, 1> VectorBool;
+  typedef Array<bool, Dynamic, Dynamic> CMatrixBool;
+  typedef Array<bool, Dynamic, 1> CVectorBool;
+
+  typedef SparseMatrix<double> SpMatrixDouble;
+  typedef SparseMatrix<float>  SpMatrixFloat;
+  typedef SparseMatrix<double>::InnerIterator SpMatrixDoubleIter;
+  typedef SparseMatrix<float>::InnerIterator  SpMatrixFloatIter;
+
+  typedef PermutationMatrix<RubyEigen::Dynamic, RubyEigen::Dynamic, int> PermutationMatrix;
+  typedef Matrix<int, Dynamic, 1> PermutationIndices;
+};

data/ext/eigen/rubyeigen_except.h

@@ -0,0 +1,15 @@
+namespace RubyEigen {
+  class EigenRuntimeError : public std::runtime_error {
+  public:
+    EigenRuntimeError(const std::string& cause) 
+      : std::runtime_error(cause) {}
+  };
+};
+
+VALUE rb_eEigenRuntimeError;
+
+/* DONOT use rb_raise here. eigen_assert is called inside the functions
+   of eigen library in C++. Calling rb_raise will cause deconstructor issues. */
+#undef eigen_assert
+#define eigen_assert(x) do {\
+ if(!Eigen::internal::copy_bool(x)) throw (RubyEigen::EigenRuntimeError(EIGEN_MAKESTRING(x))); } while(false)

data/ext/eigen/rubyeigen_gc.h

@@ -0,0 +1,5 @@
+#ifndef RUBYEIGEN_GC_H
+#define RUBYEIGEN_GC_H
+void rb_gc();
+void rubyeigen_gc_add_count(size_t sz);
+#endif

data/ext/eigen/rubyeigen_gc.hpp

@@ -0,0 +1,26 @@
+#ifndef RUBYEIGEN_GC_HPP
+#define RUBYEIGEN_GC_HPP
+
+#include "rubyeigen_gc.h"
+#include <climits>
+
+static size_t rubyeigen_gc_count = 0;
+
+size_t rubyeigen_gc_get_count() {
+  return rubyeigen_gc_count;
+}
+
+void rubyeigen_gc_reset_count() {
+  rubyeigen_gc_count = 0;
+}
+
+void rubyeigen_gc_add_count(size_t sz) {
+  const size_t max_size = (size_t)-1;
+  if(max_size - rubyeigen_gc_count > sz ) {
+    rubyeigen_gc_count += sz;
+  } else if( sz > rubyeigen_gc_count ) {
+    rubyeigen_gc_count = sz;
+  }
+}
+
+#endif

data/lib/eigen.rb

@@ -144,6 +144,12 @@ class Eigen::MatrixDouble
   private "__get_item__", "__get_block__"
 end
 
+class Eigen::MatrixFloat
+  extend  Eigen::MatrixConstructor
+  include Eigen::MatrixCommon
+  private "__get_item__", "__get_block__"
+end
+
 class Eigen::MatrixComplex
   extend  Eigen::MatrixConstructor
   include Eigen::MatrixCommon
@@ -203,3 +209,14 @@ class Eigen::SpMatrixDouble
   include Eigen::SpMatrixCommon
   private "__reserve__", "__insert__"
 end
+
+
+Thread.start do
+  loop do
+    if Eigen.gc_count > 67108864
+      GC.start
+      Eigen.reset_gc_count()
+    end
+    sleep(2)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-eigen
 version: !ruby/object:Gem::Version
-  version: 0.0.11.pre1
+  version: 0.0.11.pre2
 platform: ruby
 authors:
 - Takashi Tamura
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-05 00:00:00.000000000 Z
+date: 2016-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -328,10 +328,16 @@ files:
 - ext/eigen/eigen3/signature_of_eigen3_matrix_library
 - ext/eigen/eigen_wrap.cxx
 - ext/eigen/extconf.rb
+- ext/eigen/rubyeigen_algo.h
+- ext/eigen/rubyeigen_algo_base.h
+- ext/eigen/rubyeigen_base.h
+- ext/eigen/rubyeigen_except.h
+- ext/eigen/rubyeigen_gc.h
+- ext/eigen/rubyeigen_gc.hpp
 - lib/eigen.rb
 homepage: https://github.com/ruby-eigen/ruby-eigen
 licenses:
-- LGPL
+- LGPL-3.0
 metadata: {}
 post_install_message: 
 rdoc_options: