gps_pvt 0.9.2 → 0.9.4

data/ext/ninja-scan-light/tool/swig/SylphideMath.i

@@ -31,9 +31,17 @@
 %include std_string.i
 //%include std_vector.i
 %include exception.i
+%include std_except.i
 
+%ignore native_exception;
 #if !defined(SWIGIMPORTED)
-%header {
+%exceptionclass native_exception;
+%typemap(throws,noblock=1) native_exception {
+  $1.regenerate();
+  SWIG_fail;
+}
+%ignore native_exception;
+%inline {
 struct native_exception : public std::exception {
 #if defined(SWIGRUBY)
   int state;
@@ -44,16 +52,6 @@ struct native_exception : public std::exception {
 #endif
 };
 }
-%exception {
-  try {
-    $action
-  } catch (const native_exception &e) {
-    e.regenerate();
-    SWIG_fail;
-  } catch (const std::exception& e) {
-    SWIG_exception_fail(SWIG_RuntimeError, e.what());
-  }
-}
 #endif
 
 %define MAKE_ACCESSOR(name, type)
@@ -125,16 +123,16 @@ class Complex;
       typedef Complex<T> value_type;
       static int asval(VALUE obj, value_type *v) {
         if(RB_TYPE_P(obj, T_COMPLEX)){
-#if RUBY_API_VERSION_CODE < 20600
+%#if RUBY_API_VERSION_CODE < 20600
           static const ID id_r(rb_intern("real")), id_i(rb_intern("imag"));
           int res = swig::asval(rb_funcall(obj, id_r, 0), &(v->real()));
           if(!SWIG_IsOK(res)){return res;}
           return swig::asval(rb_funcall(obj, id_i, 0), &(v->imaginary()));
-#else
+%#else
           int res = swig::asval(rb_complex_real(obj), &(v->real()));
           if(!SWIG_IsOK(res)){return res;}
           return swig::asval(rb_complex_imag(obj), &(v->imaginary()));
-#endif 
+%#endif 
         }else{
           v->imaginary() = T(0);
           return swig::asval(obj, &(v->real()));
@@ -150,14 +148,14 @@ class Complex;
     template <class T> struct traits_check< Complex<T>, value_category> {
       static bool check(VALUE obj) {
         if(RB_TYPE_P(obj, T_COMPLEX)){
-#if RUBY_API_VERSION_CODE < 20600
+%#if RUBY_API_VERSION_CODE < 20600
           static const ID id_r(rb_intern("real")), id_i(rb_intern("imag"));
           return swig::check<T>(rb_funcall(obj, id_r, 0))
               && swig::check<T>(rb_funcall(obj, id_i, 0));
-#else
+%#else
           return swig::check<T>(rb_complex_real(obj))
               && swig::check<T>(rb_complex_imag(obj));
-#endif
+%#endif
         }else{
           return swig::check<T>(obj);
         }
@@ -347,12 +345,6 @@ struct MatrixViewFilter : public BaseView {
     res.view().partial(new_rows, new_columns, row_offset, column_offset);
     return res;
   }
-  template <class T, class Array2D_Type, class ViewType>
-  static Matrix_Frozen<T, Array2D_Type, self_t> partial(
-      const Matrix_Frozen<T, Array2D_Type, ViewType> &orig,
-      const unsigned int &new_rows, const unsigned int &new_columns) {
-    return partial(orig, new_rows, new_columns, 0, 0);
-  }
 
   template<class CharT, class Traits>
   friend std::basic_ostream<CharT, Traits> &operator<<(
@@ -414,17 +406,27 @@ class Matrix_Frozen {
     template <class T2, class Array2D_Type2, class ViewType2>
     bool operator==(const Matrix_Frozen<T2, Array2D_Type2, ViewType2> &matrix) const noexcept;
     // bool operator!= // automatically defined
-    
+
     bool isSquare() const noexcept;
     bool isDiagonal() const noexcept;
+    bool isLowerTriangular() const noexcept;
+    bool isUpperTriangular() const noexcept;
     bool isSymmetric() const noexcept;
+    bool isHermitian() const noexcept;
+    bool isSkewSymmetric() const noexcept;
+    bool isNormal() const noexcept;
+    bool isOrthogonal() const noexcept;
+    bool isUnitary() const noexcept;
     
-    T trace(const bool &do_check = true) const;
+    T trace() const;
     T sum() const noexcept;
     
     // bool isLU() const noexcept
     
-    T determinant(const bool &do_check = true) const;
+    T determinant() const;
+    unsigned int rank() const;
+    T cofactor(
+        const unsigned int &row, const unsigned int &column) const;
 };
 
 template <class T, class Array2D_Type, class ViewType = MatrixViewBase<> >
@@ -472,6 +474,11 @@ typedef MatrixViewTranspose<MatrixViewSizeVariable<MatrixViewOffset<MatrixViewBa
 
 %{
 struct MatrixUtil {
+  struct each_break_t {
+    unsigned int r, c;
+    each_break_t(const unsigned int &row, const unsigned int &column)
+        : r(row), c(column) {}
+  };
   enum each_which_t {
     EACH_ALL,
     EACH_DIAGONAL,
@@ -480,6 +487,7 @@ struct MatrixUtil {
     EACH_UPPER,
     EACH_STRICT_LOWER,
     EACH_STRICT_UPPER,
+    EACH_UNKNOWN,
   };
   template <class T, 
       class Array2D_Type, class ViewType,
@@ -490,7 +498,7 @@ struct MatrixUtil {
         const T &src_elm, T *dst_elm,
         const unsigned int &i, const unsigned int &j),
       const each_which_t &each_which = EACH_ALL,
-      Matrix<T, Array2D_Type2, ViewType2> *dst = NULL){
+      Matrix<T, Array2D_Type2, ViewType2> *dst = NULL) {
     unsigned int i_max(src.rows()), j_max(src.columns());
     switch(each_which){
       case EACH_DIAGONAL:
@@ -546,10 +554,8 @@ struct MatrixUtil {
     }
   }
 #if defined(SWIGRUBY)
-  static const each_which_t &sym2each_which(const VALUE &value){
-    if(!RB_TYPE_P(value, T_SYMBOL)){
-      std::runtime_error("Symbol is required");
-    }
+  static each_which_t sym2each_which(const VALUE &value){
+    if(!RB_TYPE_P(value, T_SYMBOL)){return EACH_UNKNOWN;}
     static const struct {
       VALUE sym;
       each_which_t which;
@@ -566,9 +572,7 @@ struct MatrixUtil {
     while(value != cmp[i].sym){
       if(++i >= (sizeof(cmp) / sizeof(cmp[0]))){break;}
     }
-    if(i >= (sizeof(cmp) / sizeof(cmp[0]))){
-      std::runtime_error("Unknown enumerate direction");
-    }
+    if(i >= (sizeof(cmp) / sizeof(cmp[0]))){return EACH_UNKNOWN;}
     return cmp[i].which;
   }
 #endif
@@ -602,16 +606,16 @@ struct MatrixUtil {
     if(value && RB_TYPE_P(*value, T_ARRAY)){
       if(RB_TYPE_P(RARRAY_AREF(*value, 0), T_ARRAY)){ // [[r0c0, r0c1, ...], ...]
         if((unsigned int)RARRAY_LEN(*value) < r){
-          throw std::runtime_error("Length is too short");
+          throw std::invalid_argument("Length is too short");
         }
         VALUE value_r;
         for(; i_elm < len; i_elm++){
           if(j == 0){
             value_r = RARRAY_AREF(*value, i);
             if(!RB_TYPE_P(value_r, T_ARRAY)){
-              throw std::runtime_error("double array [[...], ...] is required");
+              throw std::invalid_argument("double array [[...], ...] is required");
             }else if((unsigned int)RARRAY_LEN(value_r) < c){
-              throw std::runtime_error("Length is too short");
+              throw std::invalid_argument("Length is too short");
             }
           }
           v_elm = RARRAY_AREF(value_r, j);
@@ -620,7 +624,7 @@ struct MatrixUtil {
         }
       }else{ // [r0c0, r0c1, ...]
         if((unsigned int)RARRAY_LEN(*value) < len){
-          throw std::runtime_error("Length is too short");
+          throw std::invalid_argument("Length is too short");
         }
         for(; i_elm < len; i_elm++){
           v_elm = RARRAY_AREF(*value, i_elm);
@@ -647,7 +651,7 @@ struct MatrixUtil {
     if(replaced && (i_elm < len)){
       std::stringstream s;
       s << "Unexpected input [" << i << "," << j << "]: ";
-      throw std::runtime_error(s.str().append(inspect_str(v_elm)));
+      throw std::invalid_argument(s.str().append(inspect_str(v_elm)));
     }
 #endif
     return replaced;
@@ -668,6 +672,14 @@ struct MatrixUtil {
 %}
 
 %extend Matrix_Frozen {
+  %catches(std::logic_error) trace;
+  %catches(std::out_of_range) partial;
+  %catches(std::out_of_range) rowVector;
+  %catches(std::out_of_range) columnVector;
+  %catches(std::logic_error, std::runtime_error) determinant;
+  %catches(std::logic_error) rank;
+  %catches(std::logic_error, std::runtime_error) cofactor;
+
   T __getitem__(const unsigned int &row, const unsigned int &column) const {
     return ($self)->operator()(row, column);
   }
@@ -705,6 +717,7 @@ struct MatrixUtil {
     return (Matrix<T, Array2D_Dense<T> >)(($self)->operator-());
   }
   
+  %catches(std::invalid_argument) operator+;
   template <class T2, class Array2D_Type2, class ViewType2>
   Matrix<T, Array2D_Dense<T> > operator+(
       const Matrix_Frozen<T2, Array2D_Type2, ViewType2> &matrix) const {
@@ -715,6 +728,7 @@ struct MatrixUtil {
     return (Matrix<T, Array2D_Dense<T> >)(($self)->operator+(scalar));
   }
   
+  %catches(std::invalid_argument) operator-;
   template <class T2, class Array2D_Type2, class ViewType2>
   Matrix<T, Array2D_Dense<T> > operator-(
       const Matrix_Frozen<T2, Array2D_Type2, ViewType2> &matrix) const {
@@ -725,12 +739,36 @@ struct MatrixUtil {
     return (Matrix<T, Array2D_Dense<T> >)(($self)->operator-(scalar));
   }
   
+#ifdef SWIGRUBY
+  %alias entrywise_product "hadamard_product";
+#endif
+  %catches(std::invalid_argument) entrywise_product;
   template <class T2, class Array2D_Type2, class ViewType2>
-  Matrix<T, Array2D_Dense<T> > operator*(
+  Matrix<T, Array2D_Dense<T> > entrywise_product(
       const Matrix_Frozen<T2, Array2D_Type2, ViewType2> &matrix) const {
+    return (Matrix<T, Array2D_Dense<T> >)(($self)->entrywise_product(matrix));
+  }
+  INSTANTIATE_MATRIX_FUNC(entrywise_product, entrywise_product);
+  
+  template <class T2, class Array2D_Type2, class ViewType2>
+  Matrix<T, Array2D_Dense<T> > operator*(
+      const Matrix_Frozen<T2, Array2D_Type2, ViewType2> &matrix)
+      const throw(std::invalid_argument) {
     return (Matrix<T, Array2D_Dense<T> >)(($self)->operator*(matrix));
   }
   INSTANTIATE_MATRIX_FUNC(operator*, __mul__);
+  
+  // TODO __pow__ for **
+  // TODO __pos__ for +@
+
+  Matrix<T, Array2D_Dense<T> > first_minor(
+      const unsigned int &row,
+      const unsigned int &column) const noexcept {
+    return (Matrix<T, Array2D_Dense<T> >)(($self)->matrix_for_minor(row, column));
+  }
+  Matrix<T, Array2D_Dense<T> > adjugate() const {
+    return (Matrix<T, Array2D_Dense<T> >)(($self)->adjugate());
+  }
 
   %typemap(in,numinputs=0)
       Matrix<T, Array2D_Dense<T> > &output_L (Matrix<T, Array2D_Dense<T> > temp),
@@ -750,6 +788,7 @@ struct MatrixUtil {
       Matrix<T, Array2D_Dense<T> > &output_R {
     %append_output(SWIG_NewPointerObj((new $*1_ltype(*$1)), $1_descriptor, SWIG_POINTER_OWN));
   }
+  %catches(std::logic_error, std::runtime_error) lup;
   void lup(
       Matrix<T, Array2D_Dense<T> > &output_L, 
       Matrix<T, Array2D_Dense<T> > &output_U, 
@@ -775,6 +814,7 @@ struct MatrixUtil {
     output_U = LU.partial($self->rows(), $self->columns(), 0, $self->rows()).copy();
     output_P = buf.P();
   }
+  %catches(std::logic_error) ud;
   void ud(
       Matrix<T, Array2D_Dense<T> > &output_U, 
       Matrix<T, Array2D_Dense<T> > &output_D) const {
@@ -790,12 +830,14 @@ struct MatrixUtil {
     output_R = QR.partial($self->rows(), $self->columns(), 0, $self->rows()).copy();
   }
 
+  %catches(std::logic_error, std::runtime_error) inverse;
   Matrix<T, Array2D_Dense<T> > inverse() const {
     return (Matrix<T, Array2D_Dense<T> >)(($self)->inverse());
   }
   template <class T2, class Array2D_Type2, class ViewType2>
   Matrix<T, Array2D_Dense<T> > operator/(
-      const Matrix_Frozen<T2, Array2D_Type2, ViewType2> &matrix) const {
+      const Matrix_Frozen<T2, Array2D_Type2, ViewType2> &matrix)
+      const throw(std::logic_error, std::runtime_error) {
     return (Matrix<T, Array2D_Dense<T> >)(($self)->operator/(matrix));
   }
   INSTANTIATE_MATRIX_FUNC(operator/, __div__);
@@ -805,16 +847,33 @@ struct MatrixUtil {
     s << $self->inspect();
     return s.str();
   }
+  
+  /* The followings are better to be implemented in Ruby
+   * combine, hstack, vstack (due to their arguments are variable)
+   */
 
 #ifdef SWIGRUBY
   %rename("square?") isSquare;
   %rename("diagonal?") isDiagonal;
+  %rename("lower_triangular?") isLowerTriangular;
+  %rename("upper_triangular?") isUpperTriangular;
   %rename("symmetric?") isSymmetric;
+  %rename("hermitian?") isHermitian;
+  %rename("skew_symmetric?") isSkewSymmetric;
+  %alias isSkewSymmetric "antisymmetric?"
+  %rename("normal?") isNormal;
+  %rename("orthogonal?") isOrthogonal;
+  %rename("unitary?") isUnitary;
   %rename("different_size?") isDifferentSize;
+  %alias __getitem__ "element,component";
+  // %alias __eq__ "eql?"; // Intentionally commented out because eql? is more strict than ==
+  %alias rows "row_size,row_count";
+  %alias columns "column_size,column_count";
   %alias trace "tr";
   %alias determinant "det";
   %alias inverse "inv";
   %alias transpose "t";
+  %alias conjugate "conj";
   %alias lup "lup_decomposition";
   %alias ud "ud_decomposition";
   %alias qr "qr_decomposition";
@@ -822,7 +881,7 @@ struct MatrixUtil {
   %fragment(SWIG_From_frag(Matrix_Frozen_Helper<T>), "header", 
       fragment=SWIG_Traits_frag(T)){
     template <bool with_index = false, bool assign = false>
-    static inline void matrix_yield_internal(
+    static inline VALUE matrix_yield_internal(
         const T &src, T *dst, const unsigned int &i, const unsigned int &j){
       SWIG_Object v;
       if(with_index){
@@ -835,8 +894,9 @@ struct MatrixUtil {
       if(assign && !SWIG_IsOK(swig::asval(v, dst))){
         std::stringstream s;
         s << "Unknown input (T expected) [" << i << "," << j << "]: ";
-        throw std::runtime_error(s.str().append(inspect_str(v)));
+        throw std::invalid_argument(s.str().append(inspect_str(v)));
       }
+      return v;
     }
     static void matrix_yield(
         const T &src, T *dst, const unsigned int &i, const unsigned int &j){
@@ -854,11 +914,17 @@ struct MatrixUtil {
         const T &src, T *dst, const unsigned int &i, const unsigned int &j){
       matrix_yield_internal<true, true>(src, dst, i, j);
     }
+    
+    static void matrix_yield_check(
+        const T &src, T *dst, const unsigned int &i, const unsigned int &j){
+      VALUE res(matrix_yield_internal<false, false>(src, dst, i, j));
+      if(RTEST(res)){throw typename MatrixUtil::each_break_t(i, j);}
+    }
     static void (*matrix_each(const T *))
         (const T &, T *, const unsigned int &, const unsigned int &) {
       ID id_thisf(rb_frame_this_func()), id_callee(rb_frame_callee());
       static const ID 
-          id_map(rb_intern("map")), id_mapb(rb_intern("map!")), 
+          id_map(rb_intern("map")), id_mapb(rb_intern("map!")),
           id_eachwi(rb_intern("each_with_index"));
       if((id_thisf == id_map) || (id_thisf == id_mapb)){
         static const ID with_index[] = {
@@ -884,37 +950,63 @@ struct MatrixUtil {
     }
     $1 = matrix_each((const T *)0);
   }
-  %typemap(typecheck) const typename MatrixUtil::each_which_t &each_which {
-    $1 = RB_TYPE_P($input, T_SYMBOL);
+  %typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER) const typename MatrixUtil::each_which_t each_which {
+    $1 = (MatrixUtil::sym2each_which($input) != MatrixUtil::EACH_UNKNOWN);
   }
-  %typemap(in) const typename MatrixUtil::each_which_t &each_which {
-    try{
-      $1 = &const_cast<typename MatrixUtil::each_which_t &>(MatrixUtil::sym2each_which($input));
-    }catch(std::runtime_error &e){
-      SWIG_exception(SWIG_TypeError, e.what());
+  %typemap(in) const typename MatrixUtil::each_which_t each_which {
+    $1 = MatrixUtil::sym2each_which($input);
+    if($1 == MatrixUtil::EACH_UNKNOWN){
+      SWIG_exception(SWIG_ValueError,
+          std::string("Unknown enumerate direction: ").append(inspect_str($1)).c_str());
     }
   }
+  %catches(native_exception) each;
   const Matrix_Frozen<T, Array2D_Type, ViewType> &each(
       void (*each_func)(
         const T &src, T *dst,
         const unsigned int &i, const unsigned int &j), 
-      const typename MatrixUtil::each_which_t &each_which = MatrixUtil::EACH_ALL) const {
+      const typename MatrixUtil::each_which_t each_which = MatrixUtil::EACH_ALL) const {
     MatrixUtil::each(*$self, each_func, each_which);
     return *$self;
   }
   %alias each "each_with_index";
   
+  %catches(native_exception, std::invalid_argument) map;
   Matrix<T, Array2D_Dense<T> > map(
       void (*each_func)(
         const T &src, T *dst,
         const unsigned int &i, const unsigned int &j), 
-      const typename MatrixUtil::each_which_t &each_which = MatrixUtil::EACH_ALL) const {
+      const typename MatrixUtil::each_which_t each_which = MatrixUtil::EACH_ALL) const {
     Matrix<T, Array2D_Dense<T> > res($self->operator Matrix<T, Array2D_Dense<T> >());
     MatrixUtil::each(*$self, each_func, each_which, &res);
     return res;
   }
   %alias map "collect,map_with_index,collect_with_index";
   
+  %catches(native_exception) index;
+  VALUE index(
+      const typename MatrixUtil::each_which_t each_which = MatrixUtil::EACH_ALL) const {
+    try{
+      MatrixUtil::each(*$self, matrix_yield_check, each_which);
+      return Qnil;
+    }catch(const typename MatrixUtil::each_break_t &each_break){
+      return rb_ary_new_from_args(2, UINT2NUM(each_break.r), UINT2NUM(each_break.c));
+    }
+  }
+  %typemap(check,noblock=1) VALUE idx_selector {
+    if(MatrixUtil::sym2each_which($1) == MatrixUtil::EACH_UNKNOWN){
+      SWIG_exception(SWIG_ValueError,
+          std::string("Unknown enumerate direction: ").append(inspect_str($1)).c_str());
+    }
+  }
+  VALUE index(VALUE value, VALUE idx_selector = Qnil) const {
+    return rb_block_call(
+        rb_current_receiver(), rb_frame_callee(),
+        (RTEST(idx_selector) ? 1 : 0), &idx_selector,
+        (rb_block_call_func_t)rb_equal, value);
+  }
+  %alias index "find_index";
+  
   SWIG_Object to_a() const {
     unsigned int i_max($self->rows()), j_max($self->columns());
     SWIG_Object res = rb_ary_new2(i_max);
@@ -950,7 +1042,8 @@ MAKE_TO_S(Matrix_Frozen)
   %fragment(SWIG_Traits_frag(T));
 
   Matrix(const unsigned int &rows, const unsigned int &columns, 
-      const void *replacer = NULL){
+      const void *replacer = NULL)
+      throw(native_exception, std::invalid_argument) {
     Matrix<T, Array2D_Type, ViewType> res(rows, columns);
     MatrixUtil::replace(res, replacer);
     return new Matrix<T, Array2D_Type, ViewType>(res);
@@ -964,7 +1057,7 @@ MAKE_TO_S(Matrix_Frozen)
 #if defined(SWIGRUBY)
   %fragment(SWIG_AsVal_frag(unsigned int));
   %fragment("check_value"{unsigned int});
-  Matrix(const void *replacer){
+  Matrix(const void *replacer) throw(native_exception, std::invalid_argument) {
     const SWIG_Object *value(static_cast<const SWIG_Object *>(replacer));
     static const ID id_r(rb_intern("row_size")), id_c(rb_intern("column_size"));
     if(value && RB_TYPE_P(*value, T_ARRAY) && RB_TYPE_P(RARRAY_AREF(*value, 0), T_ARRAY)){
@@ -978,8 +1071,8 @@ MAKE_TO_S(Matrix_Frozen)
       VALUE v_r(rb_funcall(*value, id_r, 0, 0)), v_c(rb_funcall(*value, id_c, 0, 0));
       if(!SWIG_IsOK(SWIG_AsVal(unsigned int)(v_r, &r)) || is_lt_zero_after_asval(r)
           || !SWIG_IsOK(SWIG_AsVal(unsigned int)(v_c, &c)) || is_lt_zero_after_asval(c)){
-        throw std::runtime_error(
-            std::string("Unexpected length [")
+        throw std::invalid_argument(
+            std::string("Invalid length [")
               .append(inspect_str(v_r)).append(", ")
               .append(inspect_str(v_c)).append("]"));
       }
@@ -987,7 +1080,7 @@ MAKE_TO_S(Matrix_Frozen)
       MatrixUtil::replace(res, replacer);
       return new Matrix<T, Array2D_Type, ViewType>(res);
     }else{
-      throw std::runtime_error("double array [[...], ...] or Matrix is required");
+      throw std::invalid_argument("double array [[...], ...] or Matrix is required");
     }
   }
 #endif
@@ -1026,11 +1119,13 @@ MAKE_TO_S(Matrix_Frozen)
   %rename("scalar") getScalar;
   %rename("I") getI;
 
+  %catches(std::out_of_range) swap_rows;
   void swap_rows(
       self_t *self_p,
       const unsigned int &r1, const unsigned int &r2){
     $self->swapRows(r1, r2);
   }
+  %catches(std::out_of_range) swap_columns;
   void swap_columns(
       self_t *self_p,
       const unsigned int &c1, const unsigned int &c2){
@@ -1040,18 +1135,20 @@ MAKE_TO_S(Matrix_Frozen)
   template <class T2, class Array2D_Type2, class ViewType2>
   void replace(
       self_t *self_p,
-      const Matrix_Frozen<T2, Array2D_Type2, ViewType2> &matrix){
+      const Matrix_Frozen<T2, Array2D_Type2, ViewType2> &matrix)
+      throw(std::invalid_argument) {
     $self->replace(matrix);
   }
   INSTANTIATE_MATRIX_FUNC(replace, replace);
 
-  void replace(self_t *self_p, const void *replacer = NULL){
+  void replace(self_t *self_p, const void *replacer = NULL)
+      throw(native_exception, std::invalid_argument, std::runtime_error){
     if(!MatrixUtil::replace(*$self, replacer)){
       throw std::runtime_error("Unsupported replacement");
     }
   }
 
-  void replace(self_t *self_p, const T *serialized){
+  void replace(self_t *self_p, const T *serialized) throw(std::runtime_error) {
     if(!MatrixUtil::replace(*$self, serialized)){
       throw std::runtime_error("Unsupported replacement");
     }
@@ -1062,12 +1159,13 @@ MAKE_TO_S(Matrix_Frozen)
   %bang swap_columns;
   %rename("replace!") replace;
   
+  %catches(native_exception, std::invalid_argument) map_bang;
   void map_bang(
       self_t *self_p,
       void (*each_func)(
         const T &src, T *dst,
         const unsigned int &i, const unsigned int &j), 
-      const typename MatrixUtil::each_which_t &each_which = MatrixUtil::EACH_ALL){
+      const typename MatrixUtil::each_which_t each_which = MatrixUtil::EACH_ALL){
     MatrixUtil::each(*$self, each_func, each_which, $self);
   }
   %rename("map!") map_bang;
@@ -1096,6 +1194,14 @@ MAKE_TO_S(Matrix_Frozen)
     return MatView_f::partial(*$self, new_rows, new_columns, row_offset, column_offset);
 #else
     return $self->partial(new_rows, new_columns, row_offset, column_offset);
+#endif
+  }
+  Matrix_Frozen<type, storage, view_to> partial(
+      const unsigned int &new_rows, const unsigned int &new_columns) const {
+#if defined(USE_MATRIX_VIEW_FILTER)
+    return MatView_f::partial(*$self, new_rows, new_columns, 0, 0);
+#else
+    return $self->partial(new_rows, new_columns, 0, 0);
 #endif
   }
   Matrix_Frozen<type, storage, view_to> row_vector(const unsigned int &row) const {
@@ -1113,6 +1219,9 @@ MAKE_TO_S(Matrix_Frozen)
 #endif
   }
 };
+/* Ruby #row, #column, #row_vectors, #column_vectors are not intentionally implemented 
+ * because a vector is treated as a (1*n) or (n*1) matrix in C++.
+ */
 %enddef
 
 %define INSTANTIATE_MATRIX_EIGEN2(type, ctype, storage, view)
@@ -1129,10 +1238,11 @@ MAKE_TO_S(Matrix_Frozen)
       Matrix<ctype, Array2D_Dense<ctype > > &output_V {
     %append_output(SWIG_NewPointerObj((new $*1_ltype(*$1)), $1_descriptor, SWIG_POINTER_OWN));
   }
+  %catches(std::logic_error, std::runtime_error) eigen;
   void eigen(
       Matrix<ctype, Array2D_Dense<ctype > > &output_V, 
       Matrix<ctype, Array2D_Dense<ctype > > &output_D) const {
-    typedef typename Matrix_Frozen<type, storage, view >::complex_t::m_t cmat_t;
+    typedef Matrix<ctype, Array2D_Dense<ctype > > cmat_t;
     cmat_t VD($self->eigen());
     output_V = VD.partial($self->rows(), $self->rows()).copy();
     cmat_t D($self->rows(), $self->rows());
@@ -1258,7 +1368,7 @@ INSTANTIATE_MATRIX_PARTIAL(type, Array2D_Dense<type >, MatView_pt, MatView_pt);
   }
   Matrix<type, Array2D_Dense<type > > &resize(
       const unsigned int *r_p, const unsigned int *c_p){
-    unsigned int r(r_p ? *r_p : $self->rows()), c(c_p ? *c_p : self->columns());
+    unsigned int r(r_p ? *r_p : $self->rows()), c(c_p ? *c_p : $self->columns());
     Matrix<type, Array2D_Dense<type > > mat_new(r, c);
     unsigned int r_min(r), c_min(c);
     if(r_min > $self->rows()){r_min = $self->rows();}
@@ -1288,6 +1398,19 @@ INSTANTIATE_MATRIX_EIGEN(double, Complex<double>);
 INSTANTIATE_MATRIX(Complex<double>, ComplexD);
 INSTANTIATE_MATRIX_EIGEN(Complex<double>, Complex<double>);
 
+%rename("tolerance=") set_tolerance;
+%rename("tolerance") get_tolerance;
+%inline %{
+double set_tolerance(const double &width){
+  MatrixValue<double>::zero = width;
+  MatrixValue<Complex<double> >::zero = width;
+  return width;
+}
+double get_tolerance(){
+  return set_tolerance(MatrixValue<double>::zero.width);
+}
+%}
+
 #undef INSTANTIATE_MATRIX_FUNC
 #undef INSTANTIATE_MATRIX_TRANSPOSE
 #undef INSTANTIATE_MATRIX_PARTIAL

data/ext/ninja-scan-light/tool/swig/spec/GPS_spec.rb

@@ -918,7 +918,7 @@ __RINEX_CLK_TEXT__
       expect(solver.options[:skip_exclusion]).to eq(true)
       expect(solver.correction[:gps_ionospheric]).to include(:klobuchar)
       expect(solver.correction[:gps_tropospheric]).to include(:hopfield)
-      expect{solver.correction = nil}.to raise_error(RuntimeError)
+      expect{solver.correction = nil}.to raise_error(ArgumentError)
       expect{solver.correction = {
         :gps_ionospheric => [proc{|t, usr_pos, sat_pos|
               expect(t).to be_a_kind_of(GPS::Time)