gps_pvt 0.9.2 → 0.9.3

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

@@ -16,6 +16,7 @@
 %include std_common.i
 %include std_string.i
 %include exception.i
+%include std_except.i
 
 //%import "SylphideMath.i"
 
@@ -29,7 +30,13 @@ type set_ ## name (const type &v) {
 %enddef
 
 #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;
@@ -67,22 +74,15 @@ struct native_exception : public std::exception {
     }
   }
 #endif
-  %exception each {
+  %typemap(in,numinputs=0) const void *check_block {
 #ifdef SWIGRUBY
     if(!rb_block_given_p()){
-      return rb_enumeratorize(self, ID2SYM(rb_intern("each")), argc, argv);
+      return rb_enumeratorize(self, ID2SYM(rb_frame_callee()), argc, argv);
     }
 #endif
-    try {
-      $action
-    } catch (const native_exception &e) {
-      e.regenerate();
-      SWIG_fail;
-    } catch (const std::exception& e) {
-      SWIG_exception(SWIG_RuntimeError, e.what());
-    }
   }
-  void each() const {
+  %catches(native_exception) each;
+  void each(const void *check_block) const {
     for(int i(0); i < 3; ++i){
 #ifdef SWIGRUBY
       int state;

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

@@ -48,9 +48,16 @@ inline std::string to_string(const T &value){
 %include std_common.i
 %include std_string.i
 %include exception.i
+%include std_except.i
 
 #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;
@@ -61,16 +68,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
 
 #ifdef SWIGRUBY
@@ -117,47 +114,82 @@ static std::string inspect_str(const VALUE &v){
 %import "SylphideMath.i"
 %import "Coordinate.i"
 
-%extend GPS_Time {
-  %typemap(out) std::tm {
-    %append_output(SWIG_From(int)($1.tm_year + 1900));
-    %append_output(SWIG_From(int)($1.tm_mon + 1));
-    %append_output(SWIG_From(int)($1.tm_mday));
-    %append_output(SWIG_From(int)($1.tm_hour));
-    %append_output(SWIG_From(int)($1.tm_min));
-    %append_output(SWIG_From(int)($1.tm_sec));
+%typemap(in,numinputs=0) const void *check_block {
+#ifdef SWIGRUBY
+  if(!rb_block_given_p()){
+    return rb_enumeratorize(self, ID2SYM(rb_frame_callee()), argc, argv);
   }
-#if defined(SWIGRUBY)
-  %typemap(in) const std::tm & (std::tm temp = {0}) {
-    $1 = &temp;
-    int *dst[] = {
-      &(temp.tm_year),
-      &(temp.tm_mon),
-      &(temp.tm_mday),
-      &(temp.tm_hour),
-      &(temp.tm_min),
-      &(temp.tm_sec),
-    };
-    int i_max(sizeof(dst) / sizeof(dst[0]));
-    if(i_max > RARRAY_LEN($input)){i_max = RARRAY_LEN($input);}
+#endif
+}
+
+%fragment(SWIG_From_frag(std::tm), "header", fragment=SWIG_From_frag(int)) {
+SWIGINTERNINLINE SWIG_Object
+SWIG_From_dec(std::tm)(const std::tm &value){
+  SWIG_Object res(SWIG_From(int)(value.tm_year + 1900));
+  res = SWIG_AppendOutput(res, SWIG_From(int)(value.tm_mon + 1));
+  res = SWIG_AppendOutput(res, SWIG_From(int)(value.tm_mday));
+  res = SWIG_AppendOutput(res, SWIG_From(int)(value.tm_hour));
+  res = SWIG_AppendOutput(res, SWIG_From(int)(value.tm_min));
+  return SWIG_AppendOutput(res, SWIG_From(int)(value.tm_sec));
+}
+}
+%fragment(SWIG_AsVal_frag(std::tm), "header", fragment=SWIG_AsVal_frag(int)){
+SWIGINTERN int
+SWIG_AsVal_dec(std::tm)(SWIG_Object obj, std::tm *val) {
+#ifdef SWIGRUBY
+  int *dst[] = {
+    &(val->tm_year),
+    &(val->tm_mon),
+    &(val->tm_mday),
+    &(val->tm_hour),
+    &(val->tm_min),
+    &(val->tm_sec),
+  };
+  if(RB_TYPE_P(obj, T_ARRAY)){
+    int i_max(RARRAY_LEN(obj));
+    if(i_max > sizeof(dst) / sizeof(dst[0])){return SWIG_ERROR;}
+    VALUE obj_i;
+    int v;
     for(int i(0); i < i_max; ++i){
-      SWIG_Object obj = rb_ary_entry($input, i);
-      int v;
-      if(SWIG_IsOK(SWIG_AsVal(int)(obj, &v))){
-        if(dst[i] == &(temp.tm_year)){
+      obj_i = RARRAY_AREF(obj, i);
+      if(SWIG_IsOK(SWIG_AsVal(int)(obj_i, &v))){
+        if(dst[i] == &(val->tm_year)){
           *dst[i] = v - 1900;
-        }else if(dst[i] == &(temp.tm_mon)){
+        }else if(dst[i] == &(val->tm_mon)){
           *dst[i] = v - 1;
         }else{
           *dst[i] = v;
         }
       }else{
-        SWIG_exception(SWIG_TypeError, "int is expected");
+        SWIG_exception(SWIG_TypeError, 
+            std::string("Unexpected input [").append(std::to_string(i)).append("]: ")
+              .append(inspect_str(obj_i)).c_str());
       }
     }
+    return SWIG_OK;
   }
-  %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) const std::tm & {
-    $1 = (TYPE($input) == T_ARRAY) ? 1 : 0;
+#endif
+  return SWIG_ERROR;
+}
+}
+%typemap(out, fragment=SWIG_From_frag(std::tm)) std::tm {
+  $result = SWIG_From(std::tm)($1);
+}
+%typemap(in, fragment=SWIG_AsVal_frag(std::tm)) const std::tm & (std::tm temp = {0}) {
+  if(SWIG_AsVal(std::tm)($input, $1 = &temp) != SWIG_OK){
+    SWIG_exception(SWIG_TypeError, "int[1..6] is expected");
   }
+}
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) const std::tm & {
+#ifdef SWIGRUBY
+  $1 = (TYPE($input) == T_ARRAY) ? 1 : 0;
+#else
+  $1 = 0;
+#endif
+}
+
+%extend GPS_Time {
+#if defined(SWIGRUBY)
   %typemap(varout,fragment="SWIG_Traits_frag(FloatT)") leap_second_event_t [] {
     $result = rb_ary_new2(sizeof($1) / sizeof($1[0]));
     for(std::size_t i(0); i < sizeof($1) / sizeof($1[0]); ++i){
@@ -275,11 +307,12 @@ struct GPS_Ionospheric_UTC_Parameters : public GPS_SpaceNode<FloatT>::Ionospheri
   MAKE_ACCESSOR(WN_LSF, unsigned int);
   MAKE_ACCESSOR(DN, unsigned int);
   MAKE_ACCESSOR(delta_t_LSF, int);
+  %catches(std::invalid_argument) parse;
   static GPS_Ionospheric_UTC_Parameters<FloatT> parse(const unsigned int buf[10]){
     typedef typename GPS_SpaceNode<FloatT>
         ::BroadcastedMessage<unsigned int, 30> parser_t;
     if((parser_t::subframe_id(buf) != 4) || (parser_t::sv_page_id(buf) != 56)){
-      throw std::runtime_error("Not valid data");
+      throw std::invalid_argument("Not valid data");
     }
     typename GPS_SpaceNode<FloatT>::Ionospheric_UTC_Parameters::raw_t raw;
     raw.update<2, 0>(buf);
@@ -894,11 +927,12 @@ struct GPS_User_PVT
     ERROR_VELOCITY_LS,
   };
   int error_code() const {return (int)(base_t::error_code);}
-  const GPS_Time<FloatT> &receiver_time() const {return base_t::receiver_time;}
-  const System_XYZ<FloatT, WGS84> &xyz() const {return base_t::user_position.xyz;}
-  const System_LLH<FloatT, WGS84> &llh() const {return base_t::user_position.llh;}
+  // Returning Type because returning const Type & causes reference problem after GC
+  GPS_Time<FloatT> receiver_time() const {return base_t::receiver_time;}
+  System_XYZ<FloatT, WGS84> xyz() const {return base_t::user_position.xyz;}
+  System_LLH<FloatT, WGS84> llh() const {return base_t::user_position.llh;}
   const FloatT &receiver_error() const {return base_t::receiver_error;}
-  const System_ENU<FloatT, WGS84> &velocity() const {return base_t::user_velocity_enu;}
+  System_ENU<FloatT, WGS84> velocity() const {return base_t::user_velocity_enu;}
   const FloatT &receiver_error_rate() const {return base_t::receiver_error_rate;}
   const FloatT &gdop() const {return base_t::dop.g;}
   const FloatT &pdop() const {return base_t::dop.p;}
@@ -975,23 +1009,9 @@ struct GPS_User_PVT
 %extend GPS_Measurement {
   %ignore items_t;
   %ignore items;
-  %exception each {
-#ifdef SWIGRUBY
-    if(!rb_block_given_p()){
-      return rb_enumeratorize(self, ID2SYM(rb_intern("each")), argc, argv);
-    }
-#endif
-    try {
-      $action
-    } catch (const native_exception &e) {
-      e.regenerate();
-      SWIG_fail;
-    } catch (const std::exception& e) {
-      SWIG_exception_fail(SWIG_RuntimeError, e.what());
-    }
-  }
   %fragment(SWIG_Traits_frag(FloatT));
-  void each() const {
+  %catches(native_exception) each;
+  void each(const void *check_block) const {
     for(typename GPS_Measurement<FloatT>::items_t::const_iterator
           it(self->items.begin()), it_end(self->items.end());
         it != it_end; ++it){
@@ -1322,6 +1342,7 @@ struct HookableSolver : public BaseT {
   %ignore user_correctors;
   %immutable hooks;
   %ignore mark;
+  %catches(native_exception, std::runtime_error) solve;
   %fragment("hook"{GPS_Solver<FloatT>}, "header",
       fragment=SWIG_From_frag(int),
       fragment=SWIG_Traits_frag(FloatT),
@@ -1385,7 +1406,7 @@ struct HookableSolver : public BaseT {
         if((!RB_TYPE_P(res_hook, T_ARRAY))
             || (RARRAY_LEN(res_hook) != prop_items)){
           throw std::runtime_error(
-              std::string("[d * ").append(std::to_string(prop_items))
+              std::string("relative_property() returning [d * ").append(std::to_string(prop_items))
                 .append("] is expected (d: " %str(FloatT) "), however ")
                 .append(inspect_str(res_hook)));
         }
@@ -1393,7 +1414,7 @@ struct HookableSolver : public BaseT {
           VALUE v(RARRAY_AREF(res_hook, i));
           if(!SWIG_IsOK(swig::asval(v, &res.values[i]))){
             throw std::runtime_error(
-                std::string(%str(FloatT) " is exepcted, however ")
+                std::string("relative_property() returning " %str(FloatT) " is exepcted, however ")
                   .append(inspect_str(v))
                   .append(" @ [").append(std::to_string(i)).append("]"));
           }
@@ -1516,7 +1537,7 @@ struct HookableSolver : public BaseT {
       list_t input;
       if(update){
         if(!RB_TYPE_P(hash, T_HASH)){
-          throw std::runtime_error(
+          throw std::invalid_argument(
               std::string("Hash is expected, however ").append(inspect_str(hash)));
         }
         for(std::size_t i(0); i < sizeof(k_root) / sizeof(k_root[0]); ++i){
@@ -1594,6 +1615,7 @@ struct HookableSolver : public BaseT {
   VALUE get_correction() const {
     return const_cast<GPS_Solver<FloatT> *>(self)->update_correction(false, Qnil);
   }
+  %catches(std::invalid_argument) set_correction;
   VALUE set_correction(VALUE hash){
     return self->update_correction(true, hash);
   }
@@ -1824,23 +1846,9 @@ struct GPS_Solver
 %fragment(SWIG_From_frag(char));
 
 %extend RINEX_Observation {
-  %exception read {
-#ifdef SWIGRUBY
-    if(!rb_block_given_p()){
-      return rb_enumeratorize(self, ID2SYM(rb_intern("read")), argc, argv);
-    }
-#endif
-    try {
-      $action
-    } catch (const native_exception &e) {
-      e.regenerate();
-      SWIG_fail;
-    } catch (const std::exception& e) {
-      SWIG_exception_fail(SWIG_RuntimeError, e.what());
-    }
-  }
   %fragment(SWIG_Traits_frag(FloatT));
-  static void read(const char *fname) {
+  %catches(native_exception) read;
+  static void read(const char *fname, const void *check_block) {
     std::fstream fin(fname, std::ios::in | std::ios::binary);
     struct reader_t : public RINEX_OBS_Reader<FloatT> {
       typedef RINEX_OBS_Reader<FloatT> super_t;

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)
@@ -548,7 +546,7 @@ 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");
+      std::invalid_argument("Symbol is required");
     }
     static const struct {
       VALUE sym;
@@ -567,7 +565,7 @@ struct MatrixUtil {
       if(++i >= (sizeof(cmp) / sizeof(cmp[0]))){break;}
     }
     if(i >= (sizeof(cmp) / sizeof(cmp[0]))){
-      std::runtime_error("Unknown enumerate direction");
+      std::invalid_argument("Unknown enumerate direction");
     }
     return cmp[i].which;
   }
@@ -602,16 +600,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 +618,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 +645,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 +666,12 @@ 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;
+
   T __getitem__(const unsigned int &row, const unsigned int &column) const {
     return ($self)->operator()(row, column);
   }
@@ -705,6 +709,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 +720,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 {
@@ -727,7 +733,8 @@ struct MatrixUtil {
   
   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::invalid_argument) {
     return (Matrix<T, Array2D_Dense<T> >)(($self)->operator*(matrix));
   }
   INSTANTIATE_MATRIX_FUNC(operator*, __mul__);
@@ -750,6 +757,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 +783,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 +799,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__);
@@ -835,7 +846,7 @@ 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)));
       }
     }
     static void matrix_yield(
@@ -890,10 +901,11 @@ struct MatrixUtil {
   %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());
+    }catch(std::invalid_argument &e){
+      SWIG_exception(SWIG_ValueError, e.what());
     }
   }
+  %catches(native_exception) each;
   const Matrix_Frozen<T, Array2D_Type, ViewType> &each(
       void (*each_func)(
         const T &src, T *dst,
@@ -904,6 +916,7 @@ struct MatrixUtil {
   }
   %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,
@@ -950,7 +963,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 +978,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 +992,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 +1001,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 +1040,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 +1056,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,6 +1080,7 @@ 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)(
@@ -1129,6 +1148,7 @@ 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 {
@@ -1258,7 +1278,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();}

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)

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

@@ -53,7 +53,7 @@ shared_examples 'Matrix' do
       [:row_size, :column_size].each{|f|
         a = a_gen.call
         a.define_singleton_method(f){-1}
-        expect{ mat_type::new(a) }.to raise_error(RuntimeError)
+        expect{ mat_type::new(a) }.to raise_error(ArgumentError)
       }
     end
     it 'is invoked with I, identity, unit' do
@@ -70,12 +70,12 @@ shared_examples 'Matrix' do
     end
     it 'sets its elements with [], [[]], Matrix' do
       expect( mat_type::new(params[:rc][0], params[:rc][1], compare_with.flatten).to_a ).to eq(compare_with)
-      expect{ mat_type::new(params[:rc][0], params[:rc][1], compare_with.flatten[0..-2]) }.to raise_error(RuntimeError)
+      expect{ mat_type::new(params[:rc][0], params[:rc][1], compare_with.flatten[0..-2]) }.to raise_error(ArgumentError)
       expect( mat_type::new(params[:rc][0], params[:rc][1], compare_with.flatten + [gen_elm.call]).to_a ).to eq(compare_with)
-      expect{ mat_type::new(params[:rc][0], params[:rc][1], compare_with.flatten[0..-2] + [nil]) }.to raise_error(RuntimeError)
+      expect{ mat_type::new(params[:rc][0], params[:rc][1], compare_with.flatten[0..-2] + [nil]) }.to raise_error(ArgumentError)
 
       expect( mat_type::new(params[:rc][0], params[:rc][1], compare_with).to_a ).to eq(compare_with)
-      expect{ mat_type::new(params[:rc][0], params[:rc][1], compare_with[0..-2]) }.to raise_error(RuntimeError)
+      expect{ mat_type::new(params[:rc][0], params[:rc][1], compare_with[0..-2]) }.to raise_error(ArgumentError)
       expect( mat_type::new(params[:rc][0], params[:rc][1], compare_with + [params[:rc][1].times.map{gen_elm.call}]).to_a ).to eq(compare_with)
       expect( mat_type::new(compare_with).to_a ).to eq(compare_with)
 
@@ -83,7 +83,7 @@ shared_examples 'Matrix' do
     end
     it 'sets its elements with {}' do
       expect( mat_type::new(*params[:rc]){|i, j| compare_with[i][j]}.to_a ).to eq(compare_with)
-      expect{ mat_type::new(*params[:rc]){nil}.to_a }.to raise_error(RuntimeError)
+      expect{ mat_type::new(*params[:rc]){nil}.to_a }.to raise_error(ArgumentError)
       expect{ mat_type::new(compare_with){|i, j| compare_with[i][j]} }.to raise_error(ArgumentError)
       expect{ mat_type::new(Matrix[*compare_with]){|i, j| compare_with[i][j]} }.to raise_error(ArgumentError)
 
@@ -372,7 +372,7 @@ shared_examples 'Matrix' do
     end
     it 'have +(scalar)' do
       expect((mat[0] + 1).to_a).to eq((Matrix[*compare_with[0]] + Matrix::unit(params[:rc][0])).to_a)
-      expect{mat[2] + 1}.to raise_error(RuntimeError)
+      expect{mat[2] + 1}.to raise_error(ArgumentError)
     end
     it 'have +(mat)' do
       [[0, 1], [2, 3]].each{|i, j|
@@ -381,7 +381,7 @@ shared_examples 'Matrix' do
     end
     it 'have -(scalar)' do
       expect((mat[0] - 1).to_a).to eq((Matrix[*compare_with[0]] - Matrix::unit(params[:rc][0])).to_a)
-      expect{mat[2] - 1}.to raise_error(RuntimeError)
+      expect{mat[2] - 1}.to raise_error(ArgumentError)
     end
     it 'have -(mat)' do
       [[0, 1], [2, 3]].each{|i, j|
@@ -395,7 +395,7 @@ shared_examples 'Matrix' do
     end
     it 'have *(mat)' do
       expect((mat[0] * mat[1]).to_a).to eq((Matrix[*compare_with[0]] * Matrix[*compare_with[1]]).to_a)
-      expect{mat[2] * mat[3]}.to raise_error(RuntimeError)
+      expect{mat[2] * mat[3]}.to raise_error(ArgumentError)
       expect((mat[2] * mat[3].t).to_a).to eq((Matrix[*compare_with[2]] * Matrix[*compare_with[3]].t).to_a)
     end
     it 'have /(scalar)' do