gps_pvt 0.2.3 → 0.4.0

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

@@ -20,12 +20,14 @@
 #include "navigation/GPS.h"
 #include "navigation/SBAS.h"
 #include "navigation/QZSS.h"
+#include "navigation/GLONASS.h"
 #include "navigation/RINEX.h"
 
 #include "navigation/GPS_Solver_Base.h"
 #include "navigation/GPS_Solver.h"
 #include "navigation/GPS_Solver_RAIM.h"
 #include "navigation/SBAS_Solver.h"
+#include "navigation/GLONASS_Solver.h"
 
 #if defined(__cplusplus) && (__cplusplus < 201103L)
 namespace std {
@@ -153,6 +155,12 @@ static std::string inspect_str(const VALUE &v){
     $1 = (TYPE($input) == T_ARRAY) ? 1 : 0;
   }
 #endif
+  %ignore canonicalize();
+  %ignore GPS_Time(const int &_week, const float_t &_seconds);
+  %typemap(in, numinputs=0) void *dummy "";
+  GPS_Time(const int &week_, const float_t &seconds_, void *dummy){
+    return &((new GPS_Time<FloatT>(week_, seconds_))->canonicalize());
+  }
   %apply int *OUTPUT { int *week };
   %apply FloatT *OUTPUT { FloatT *seconds };
   void to_a(int *week, FloatT *seconds) const {
@@ -500,6 +508,160 @@ struct SBAS_Ephemeris : public SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephe
 
 %include navigation/SBAS.h
 
+%inline %{
+template <class FloatT>
+struct GLONASS_Ephemeris 
+    : public GLONASS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris_with_GPS_Time {
+  typedef typename GLONASS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris_with_GPS_Time eph_t;
+  unsigned int super_frame, has_string;
+  typename eph_t::raw_t raw;
+  void invalidate() {
+    super_frame = 0;
+    has_string = 0;
+  }
+  bool is_consistent() const {
+    return has_string == 0x1F;
+  }
+  GLONASS_Ephemeris() : eph_t() {
+    invalidate();
+  }
+  GLONASS_Ephemeris(const eph_t &eph) 
+      : eph_t(eph),
+      super_frame(0), has_string(0), raw() {
+    raw = *this;
+    has_string = 0x1F;
+  }
+};
+%}
+%extend GLONASS_Ephemeris {
+  MAKE_ACCESSOR(svid, unsigned int);
+  
+  MAKE_ACCESSOR(freq_ch, int); // frequency channel to be configured
+  MAKE_ACCESSOR(t_k, unsigned int);
+  MAKE_ACCESSOR(t_b, unsigned int);
+  MAKE_ACCESSOR(M, unsigned int);
+  MAKE_ACCESSOR(gamma_n, FloatT);
+  MAKE_ACCESSOR(tau_n, FloatT);
+
+  MAKE_ACCESSOR(xn, FloatT); MAKE_ACCESSOR(xn_dot, FloatT); MAKE_ACCESSOR(xn_ddot, FloatT);
+  MAKE_ACCESSOR(yn, FloatT); MAKE_ACCESSOR(yn_dot, FloatT); MAKE_ACCESSOR(yn_ddot, FloatT);
+  MAKE_ACCESSOR(zn, FloatT); MAKE_ACCESSOR(zn_dot, FloatT); MAKE_ACCESSOR(zn_ddot, FloatT);
+
+  MAKE_ACCESSOR(B_n, unsigned int);
+  MAKE_ACCESSOR(p, unsigned int);
+  MAKE_ACCESSOR(N_T, unsigned int);
+  MAKE_ACCESSOR(F_T, FloatT);
+  MAKE_ACCESSOR(n, unsigned int);
+  MAKE_ACCESSOR(delta_tau_n, FloatT);
+  MAKE_ACCESSOR(E_n, unsigned int);
+  MAKE_ACCESSOR(P1, unsigned int);
+  MAKE_ACCESSOR(P2, bool);
+  MAKE_ACCESSOR(P4, bool);
+
+  MAKE_ACCESSOR(tau_c, FloatT);
+  MAKE_ACCESSOR(tau_GPS, FloatT);
+  
+  FloatT frequency_L1() const {
+    return self->L1_frequency();
+  };
+  FloatT frequency_L2() const {
+    return self->L2_frequency();
+  };
+  GPS_Time<FloatT> base_time() const {
+    return self->base_time();
+  }
+
+  //MAKE_ACCESSOR(l_n, bool); // exists in both Ephemeris and Time_Properties
+
+  MAKE_ARRAY_INPUT(const unsigned int, buf, SWIG_AsVal(unsigned int));
+  bool parse(const unsigned int buf[4], const unsigned int &leap_seconds = 0){
+    typedef typename GLONASS_SpaceNode<FloatT>
+        ::template BroadcastedMessage<unsigned int> parser_t;
+    unsigned int super_frame(buf[3] >> 16), frame(buf[3] & 0xF), string_no(parser_t::m(buf));
+    unsigned int has_string(self->has_string);
+    if((has_string > 0) && (self->super_frame != super_frame)){
+      has_string = 0; // clean up
+    }
+    self->super_frame = super_frame;
+    has_string |= (0x1 << (string_no - 1));
+    switch(string_no){
+      case 1: self->raw.template update_string1<0, 0>(buf); break;
+      case 2: self->raw.template update_string2<0, 0>(buf); break;
+      case 3: self->raw.template update_string3<0, 0>(buf); break;
+      case 4: self->raw.template update_string4<0, 0>(buf); break;
+      case 5: {
+        self->raw.template update_string5<0, 0>(buf);
+        if(frame == 4){
+          // TODO: require special care for 50th frame? @see Table 4.9 note (4)
+        }
+        break;
+      }
+    }
+    bool updated(false);
+    if((has_string == 0x1F) && (has_string != self->has_string)){
+      updated = true;
+      // All ephemeris and time info. in the same super frame has been acquired, 
+      // and this block is called once per one same super frame.
+      // Ephemeris_with_Time::raw_t =(cast)=> Ephemeris_with_Time => Ephemeris_with_GPS_Time
+      static_cast<GLONASS_Ephemeris<FloatT>::eph_t &>(*self) 
+          = GLONASS_Ephemeris<FloatT>::eph_t(self->raw);
+      self->t_b_gps += leap_seconds;
+    }
+    self->has_string = has_string;
+    return updated;
+  }
+  FloatT clock_error(
+      const GPS_Time<FloatT> &t_arrival, const FloatT &pseudo_range = 0) const {
+    return self->clock_error(t_arrival, pseudo_range);
+  }
+  %typemap(in,numinputs=0) System_XYZ<FloatT, WGS84> & (System_XYZ<FloatT, WGS84> temp) %{
+    $1 = &temp;
+  %}
+  %typemap(argout) System_XYZ<FloatT, WGS84> & {
+    %append_output(SWIG_NewPointerObj((new $*1_ltype(*$1)), $1_descriptor, SWIG_POINTER_OWN));
+  }
+  void constellation(
+      System_XYZ<FloatT, WGS84> &position, System_XYZ<FloatT, WGS84> &velocity,
+      const GPS_Time<FloatT> &t, const FloatT &pseudo_range = 0) const {
+    typename GPS_SpaceNode<FloatT>::SatelliteProperties::constellation_t res(
+        self->constellation(t, pseudo_range));
+    position = res.position;
+    velocity = res.velocity;
+  }
+#if defined(SWIGRUBY)
+  %rename("consistent?") is_consistent;
+  %rename("in_range?") is_in_range;
+#endif
+  bool is_in_range(const GPS_Time<FloatT> &t) const {
+    // "invalidate()" is used to make raw and converted data inconsistent.
+    return self->is_valid(t);
+  }
+}
+
+%extend GLONASS_SpaceNode {
+  %fragment(SWIG_Traits_frag(FloatT));
+  %ignore satellites() const;
+  %ignore satellite(const int &);
+  %ignore latest_ephemeris() const;
+  void register_ephemeris(
+      const int &prn, const GLONASS_Ephemeris<FloatT> &eph,
+      const int &priority_delta = 1){
+    self->satellite(prn).register_ephemeris(eph, priority_delta);
+  }
+  GLONASS_Ephemeris<FloatT> ephemeris(const int &prn) const {
+    return GLONASS_Ephemeris<FloatT>(
+        %const_cast(self, GLONASS_SpaceNode<FloatT> *)->satellite(prn).ephemeris());
+  }
+  int read(const char *fname) {
+    std::fstream fin(fname, std::ios::in | std::ios::binary);
+    typename RINEX_NAV_Reader<FloatT>::space_node_list_t list = {NULL};
+    list.glonass = self;
+    return RINEX_NAV_Reader<FloatT>::read_all(fin, list);
+  }
+}
+
+%include navigation/GLONASS.h
+
 %extend GPS_User_PVT {
   %ignore solver_t;
   %ignore base_t;
@@ -591,8 +753,9 @@ struct GPS_User_PVT
   Matrix<FloatT, Array2D_Dense<FloatT> > G_enu() const {
     return proxy_t::linear_solver_t::rotate_G(base_t::G, base_t::user_position.ecef2enu());
   }
-  typename proxy_t::linear_solver_t linear_solver() const {
-    return typename proxy_t::linear_solver_t(base_t::G, base_t::W, base_t::delta_r);
+  typename proxy_t::linear_solver_t::partial_t linear_solver() const {
+    return typename proxy_t::linear_solver_t(base_t::G, base_t::W, base_t::delta_r)
+        .partial(used_satellites());
   }
   Matrix<FloatT, Array2D_Dense<FloatT> > C() const {
     return linear_solver().C();
@@ -605,14 +768,26 @@ struct GPS_User_PVT
     linear_solver().least_square(res);
     return res;
   }
+  Matrix<FloatT, Array2D_Dense<FloatT> > S_enu(
+      const Matrix<FloatT, Array2D_Dense<FloatT> > &s) const {
+    return proxy_t::linear_solver_t::rotate_S(s, base_t::user_position.ecef2enu());
+  }
   Matrix<FloatT, Array2D_Dense<FloatT> > S_enu() const {
-    return proxy_t::linear_solver_t::rotate_S(S(), base_t::user_position.ecef2enu());
+    return S_enu(S());
+  }
+  Matrix<FloatT, Array2D_Dense<FloatT> > slope_HV(
+      const Matrix<FloatT, Array2D_Dense<FloatT> > &s) const {
+    return linear_solver().slope_HV(s);
   }
   Matrix<FloatT, Array2D_Dense<FloatT> > slope_HV() const {
-    return linear_solver().slope_HV(S());
+    return slope_HV(S());
+  }
+  Matrix<FloatT, Array2D_Dense<FloatT> > slope_HV_enu(
+      const Matrix<FloatT, Array2D_Dense<FloatT> > &s) const {
+    return linear_solver().slope_HV(s, base_t::user_position.ecef2enu());
   }
   Matrix<FloatT, Array2D_Dense<FloatT> > slope_HV_enu() const {
-    return linear_solver().slope_HV(S(), base_t::user_position.ecef2enu());
+    return slope_HV_enu(S());
   }
   
   void fd(const typename base_t::detection_t **out) const {*out = &(base_t::FD);}
@@ -878,6 +1053,46 @@ struct SBAS_SolverOptions
 };
 %}
 
+%extend GLONASS_SolverOptions {
+  %ignore base_t;
+  %ignore cast_general;
+  MAKE_VECTOR2ARRAY(int);
+}
+%inline %{
+template <class FloatT>
+struct GLONASS_SolverOptions 
+    : public GLONASS_SinglePositioning<FloatT>::options_t, 
+    GPS_SolverOptions_Common<FloatT> {
+  typedef typename GLONASS_SinglePositioning<FloatT>::options_t base_t;
+  void exclude(const int &prn){base_t::exclude_prn.set(prn);}
+  void include(const int &prn){base_t::exclude_prn.reset(prn);}
+  std::vector<int> excluded() const {return base_t::exclude_prn.excluded();}
+  GPS_Solver_GeneralOptions<FloatT> *cast_general(){return this;}
+  const GPS_Solver_GeneralOptions<FloatT> *cast_general() const {return this;}
+};
+%}
+
+%header {
+template <class FloatT>
+struct GPS_RangeCorrector
+    : public GPS_Solver_Base<FloatT>::range_corrector_t {
+  SWIG_Object callback;
+  GPS_RangeCorrector(const SWIG_Object &callback_)
+      : GPS_Solver_Base<FloatT>::range_corrector_t(),
+      callback(callback_) {}
+  bool is_available(const typename GPS_Solver_Base<FloatT>::gps_time_t &t) const {
+    return false;
+  }
+  FloatT *calculate(
+      const typename GPS_Solver_Base<FloatT>::gps_time_t &t, 
+      const typename GPS_Solver_Base<FloatT>::pos_t &usr_pos, 
+      const typename GPS_Solver_Base<FloatT>::enu_t &sat_rel_pos,
+      FloatT &buf) const {
+    return NULL;
+  }
+};
+}
+
 %extend GPS_Solver {
   %ignore super_t;
   %ignore base_t;
@@ -885,10 +1100,14 @@ struct SBAS_SolverOptions
   %ignore gps;
   %ignore sbas_t;
   %ignore sbas;
+  %ignore glonass_t;
+  %ignore glonass;
   %ignore select_solver;
   %ignore relative_property;
   %ignore satellite_position;
   %ignore update_position_solution;
+  %ignore user_correctors_t;
+  %ignore user_correctors;
   %immutable hooks;
   %ignore mark;
   %fragment("hook"{GPS_Solver<FloatT>}, "header",
@@ -1033,6 +1252,38 @@ struct SBAS_SolverOptions
   %fragment("correction"{GPS_Solver<FloatT>}, "header",
       fragment=SWIG_From_frag(int),
       fragment=SWIG_Traits_frag(FloatT)){
+    template <>
+    bool GPS_RangeCorrector<FloatT>::is_available(
+        const typename GPS_Solver_Base<FloatT>::gps_time_t &t) const {
+      VALUE values[] = {
+        SWIG_NewPointerObj(
+            %const_cast(&t, GPS_Time<FloatT> *), $descriptor(GPS_Time<FloatT> *), 0),
+      };
+      VALUE res(proc_call_throw_if_error(
+          callback, sizeof(values) / sizeof(values[0]), values));
+      return RTEST(res) ? true : false;
+    }
+    template <>
+    FloatT *GPS_RangeCorrector<FloatT>::calculate(
+        const typename GPS_Solver_Base<FloatT>::gps_time_t &t,
+        const typename GPS_Solver_Base<FloatT>::pos_t &usr_pos, 
+        const typename GPS_Solver_Base<FloatT>::enu_t &sat_rel_pos,
+        FloatT &buf) const {
+      VALUE values[] = {
+        SWIG_NewPointerObj(
+            %const_cast(&t, GPS_Time<FloatT> *),
+            $descriptor(GPS_Time<FloatT> *), 0),
+        SWIG_NewPointerObj(
+            (%const_cast(&usr_pos.xyz, System_XYZ<FloatT, WGS84> *)),
+            $descriptor(System_XYZ<FloatT, WGS84> *), 0),
+        SWIG_NewPointerObj(
+            (%const_cast(&sat_rel_pos, System_ENU<FloatT, WGS84> *)),
+            $descriptor(System_ENU<FloatT, WGS84> *), 0),
+      };
+      VALUE res(proc_call_throw_if_error(
+          callback, sizeof(values) / sizeof(values[0]), values));
+      return SWIG_IsOK(swig::asval(res, &buf)) ? &buf : NULL;
+    }
     template<>
     VALUE GPS_Solver<FloatT>::update_correction(
         const bool &update, const VALUE &hash){
@@ -1042,6 +1293,8 @@ struct SBAS_SolverOptions
         ID2SYM(rb_intern("gps_tropospheric")),
         ID2SYM(rb_intern("sbas_ionospheric")),
         ID2SYM(rb_intern("sbas_tropospheric")),
+        ID2SYM(rb_intern("glonass_ionospheric")),
+        ID2SYM(rb_intern("glonass_tropospheric")),
       };
       static const VALUE k_opt(ID2SYM(rb_intern("options")));
       static const VALUE k_f_10_7(ID2SYM(rb_intern("f_10_7")));
@@ -1075,10 +1328,12 @@ struct SBAS_SolverOptions
             for(; k < sizeof(item) / sizeof(item[0]); ++k){
               if(v == item[k].sym){break;}
             }
-            if(k >= sizeof(item) / sizeof(item[0])){
-              continue; // TODO other than symbol
+            if(k >= sizeof(item) / sizeof(item[0])){ // other than symbol
+              user_correctors.push_back(GPS_RangeCorrector<FloatT>(v));
+              input[i].push_back(&user_correctors.back());
+            }else{
+              input[i].push_back(item[k].obj);
             }
-            input[i].push_back(item[k].obj);
           }
         }
         VALUE opt(rb_hash_lookup(hash, k_opt));
@@ -1105,10 +1360,12 @@ struct SBAS_SolverOptions
           for(; i < sizeof(item) / sizeof(item[0]); ++i){
             if(*it2 == item[i].obj){break;}
           }
-          if(i >= sizeof(item) / sizeof(item[0])){
-            continue; // TODO other than built-in corrector
+          if(i >= sizeof(item) / sizeof(item[0])){ // other than built-in corrector
+            rb_ary_push(v, 
+                reinterpret_cast<const GPS_RangeCorrector<FloatT> *>(*it2)->callback);
+          }else{
+            rb_ary_push(v, item[i].sym);
           }
-          rb_ary_push(v, item[i].sym);
         }
         rb_hash_aset(res, k, v);
       }
@@ -1159,15 +1416,29 @@ struct GPS_Solver
     SBAS_SinglePositioning<FloatT> solver;
     sbas_t() : space_node(), options(), solver(space_node) {}
   } sbas;
+  struct glonass_t {
+    GLONASS_SpaceNode<FloatT> space_node;
+    GLONASS_SolverOptions<FloatT> options;
+    GLONASS_SinglePositioning<FloatT> solver;
+    glonass_t() : space_node(), options(), solver(space_node) {}
+  } glonass;
   SWIG_Object hooks;
+  typedef std::vector<GPS_RangeCorrector<FloatT> > user_correctors_t;
+  user_correctors_t user_correctors;
 #ifdef SWIGRUBY
   static void mark(void *ptr){
     GPS_Solver<FloatT> *solver = (GPS_Solver<FloatT> *)ptr;
-    if(solver->hooks == Qnil){return;}
     rb_gc_mark(solver->hooks);
+    for(typename user_correctors_t::const_iterator 
+          it(solver->user_correctors.begin()), it_end(solver->user_correctors.end());
+        it != it_end; ++it){
+      rb_gc_mark(it->callback);
+    }
   }
 #endif
-  GPS_Solver() : super_t(), gps(), sbas(), hooks() {
+  GPS_Solver() : super_t(),
+      gps(), sbas(), glonass(),
+      hooks(), user_correctors() {
 #ifdef SWIGRUBY
     hooks = rb_hash_new();
 #endif
@@ -1178,20 +1449,25 @@ struct GPS_Solver
     tropospheric.push_back(&gps.solver.tropospheric_simplified);
     gps.solver.ionospheric_correction
         = sbas.solver.ionospheric_correction
+        = glonass.solver.ionospheric_correction
         = ionospheric;
     gps.solver.tropospheric_correction
         = sbas.solver.tropospheric_correction
+        = glonass.solver.tropospheric_correction
         = tropospheric;
   }
   GPS_SpaceNode<FloatT> &gps_space_node() {return gps.space_node;}
   GPS_SolverOptions<FloatT> &gps_options() {return gps.options;}
   SBAS_SpaceNode<FloatT> &sbas_space_node() {return sbas.space_node;}
   SBAS_SolverOptions<FloatT> &sbas_options() {return sbas.options;}
+  GLONASS_SpaceNode<FloatT> &glonass_space_node() {return glonass.space_node;}
+  GLONASS_SolverOptions<FloatT> &glonass_options() {return glonass.options;}
   const base_t &select_solver(
       const typename base_t::prn_t &prn) const {
     if(prn > 0 && prn <= 32){return gps.solver;}
     if(prn >= 120 && prn <= 158){return sbas.solver;}
     if(prn > 192 && prn <= 202){return gps.solver;}
+    if(prn > 0x100 && prn <= (0x100 + 24)){return glonass.solver;}
     // call order: base_t::solve => this returned by select() 
     //     => relative_property() => select_solver()
     // For not supported satellite, call loop prevention is required.
@@ -1219,6 +1495,8 @@ struct GPS_Solver
     const_cast<gps_t &>(gps).solver.update_options(gps.options);
     const_cast<sbas_t &>(sbas).space_node.update_all_ephemeris(receiver_time);
     const_cast<sbas_t &>(sbas).solver.update_options(sbas.options);
+    const_cast<glonass_t &>(glonass).space_node.update_all_ephemeris(receiver_time);
+    const_cast<glonass_t &>(glonass).solver.update_options(glonass.options);
     return super_t::solve().user_pvt(measurement.items, receiver_time);
   }
   typedef 
@@ -1233,12 +1511,27 @@ struct GPS_Solver
       &gps.solver.tropospheric_correction,
       &sbas.solver.ionospheric_correction,
       &sbas.solver.tropospheric_correction,
+      &glonass.solver.ionospheric_correction,
+      &glonass.solver.tropospheric_correction,
     };
     for(std::size_t i(0); i < sizeof(root) / sizeof(root[0]); ++i){
       do{
         if(!update){break;}
         typename range_correction_list_t::const_iterator it(list.find(i));
         if(it == list.end()){break;}
+
+        // Remove user defined unused correctors
+        for(typename base_t::range_correction_t::const_iterator
+              it2(root[i]->begin()), it2_end(root[i]->end());
+            it2 != it2_end; ++it2){
+          for(typename user_correctors_t::const_iterator
+                it3(user_correctors.begin()), it3_end(user_correctors.end());
+              it3 != it3_end; ++it3){
+            if(*it2 != &(*it3)){continue;}
+            user_correctors.erase(it3);
+          }
+        }
+
         root[i]->clear();
         for(typename range_correction_list_t::mapped_type::const_iterator
               it2(it->second.begin()), it2_end(it->second.end());
@@ -1396,6 +1689,10 @@ struct RINEX_Observation {};
 %template(SpaceNode_SBAS) SBAS_SpaceNode<type>;
 %template(SolverOptions_SBAS) SBAS_SolverOptions<type>;
 
+%template(SpaceNode_GLONASS) GLONASS_SpaceNode<type>;
+%template(Ephemeris_GLONASS) GLONASS_Ephemeris<type>;
+%template(SolverOptions_GLONASS) GLONASS_SolverOptions<type>;
+
 %template(RINEX_Observation) RINEX_Observation<type>;
 %enddef
 

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

@@ -437,8 +437,6 @@ class Matrix : public Matrix_Frozen<T, Array2D_Type, ViewType> {
 #endif
 
     typedef Matrix<T, Array2D_Type, ViewType> self_t;
-    self_t &swapRows(const unsigned int &row1, const unsigned int &row2);
-    self_t &swapColumns(const unsigned int &column1, const unsigned int &column2);
 };
 
 %inline {
@@ -995,7 +993,23 @@ MAKE_TO_S(Matrix_Frozen)
   }
 #endif
 
-  %typemap(out) self_t & "$result = self;"
+  /*
+   * Returning (*this) requires special care;
+   * "self_t &func(){return (*this);}" in a C++ file may generate
+   * a new wrapped object deleted by GC in the target language
+   * unless the care.
+   * 
+   * Work around 1)
+   *   %typemap(in, numinputs=0) self_t *self_p "";
+   *   %typemap(argout) self_t *self_p "$result = self;";
+   *   void func(self_t *self_p){...}
+   *
+   * Work around 2) (useful without overwrite of the original source, but may overfit)
+   *   %typemap(out) self_t & "$result = self;"
+   *   self_t &func(){...; return *$self;}
+   */
+  %typemap(in, numinputs=0) self_t *self_p "";
+  %typemap(argout) self_t *self_p "$result = self;";
 
   T &__setitem__(const unsigned int &row, const unsigned int &column, const T &value) {
     return (($self)->operator()(row, column) = value);
@@ -1012,41 +1026,50 @@ MAKE_TO_S(Matrix_Frozen)
 #endif
   %rename("scalar") getScalar;
   %rename("I") getI;
-  %rename("swap_rows") swapRows;
-  %rename("swap_columns") swapColumns;
+
+  void swap_rows(
+      self_t *self_p,
+      const unsigned int &r1, const unsigned int &r2){
+    $self->swapRows(r1, r2);
+  }
+  void swap_columns(
+      self_t *self_p,
+      const unsigned int &c1, const unsigned int &c2){
+    $self->swapColumns(c1, c2);
+  }
 
   template <class T2, class Array2D_Type2, class ViewType2>
-  self_t &replace(const Matrix_Frozen<T2, Array2D_Type2, ViewType2> &matrix){
-    return $self->replace(matrix);
+  void replace(
+      self_t *self_p,
+      const Matrix_Frozen<T2, Array2D_Type2, ViewType2> &matrix){
+    $self->replace(matrix);
   }
   INSTANTIATE_MATRIX_FUNC(replace, replace);
 
-  self_t &replace(const void *replacer = NULL){
+  void replace(self_t *self_p, const void *replacer = NULL){
     if(!MatrixUtil::replace(*$self, replacer)){
       throw std::runtime_error("Unsupported replacement");
     }
-    return *$self;
   }
 
-  self_t &replace(const T *serialized){
+  void replace(self_t *self_p, const T *serialized){
     if(!MatrixUtil::replace(*$self, serialized)){
       throw std::runtime_error("Unsupported replacement");
     }
-    return *$self;
   }
   
 #ifdef SWIGRUBY
-  %bang swapRows(const unsigned int &, const unsigned int &);
-  %bang swapColumns(const unsigned int &, const unsigned int &);
+  %bang swap_rows;
+  %bang swap_columns;
   %rename("replace!") replace;
   
-  self_t &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){
     MatrixUtil::each(*$self, each_func, each_which, $self);
-    return *$self;
   }
   %rename("map!") map_bang;
   %alias map_bang "collect!,map_with_index!,collect_with_index!";

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

@@ -253,6 +253,7 @@ __RINEX_OBS_TEXT__
       t_meas = GPS::Time::new(1849, 172413)
       puts "Measurement time: #{t_meas.to_a} (a.k.a #{"%d/%d/%d %02d:%02d:%02d UTC"%[*t_meas.c_tm]})"
       expect(t_meas.c_tm).to eq([2015, 6, 15, 23, 53, 33])
+      expect(GPS::Time::new(0, t_meas.serialize)).to eq(t_meas)
       
       sn.update_all_ephemeris(t_meas)
       
@@ -343,7 +344,12 @@ __RINEX_OBS_TEXT__
       expect(solver.correction[:gps_tropospheric]).to include(:hopfield)
       expect{solver.correction = nil}.to raise_error(RuntimeError)
       expect{solver.correction = {
-        :gps_ionospheric => [:klobuchar, :no_correction],
+        :gps_ionospheric => [proc{|t, usr_pos, sat_pos|
+              expect(t).to be_a_kind_of(GPS::Time)
+              expect(usr_pos).to be_a_kind_of(Coordinate::XYZ) unless usr_pos
+              expect(sat_pos).to be_a_kind_of(Coordinate::ENU) unless sat_pos
+              false
+            }, :klobuchar, :no_correction],
         :options => {:f_10_7 => 10},
       }}.not_to raise_error
       expect(solver.correction[:gps_ionospheric]).to include(:no_correction)

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

@@ -214,9 +214,19 @@ shared_examples 'Matrix' do
     it 'is swappable with swap_rows! or swap_cloumns!' do
       mat_builtin = Matrix[*compare_with[0]]
       [:swap_rows!, :swap_columns!].each.with_index{|func, i|
-        params[:rc][i].times.to_a.combination(2).to_a{|a, b|
-          mat[0].send(func, a, b)
-          mat_builtin.send(func, a, b)
+        params[:rc][i].times.to_a.combination(2).to_a.each{|a, b|
+          mat_mod = mat[0].send(func, a, b)
+          case func
+          when :swap_rows!
+            idxs = mat_builtin.row_count.times.to_a
+            idxs[a], idxs[b] = [b, a]
+            mat_builtin = Matrix::rows(mat_builtin.row_vectors.values_at(*idxs))
+          when :swap_columns!
+            idxs = mat_builtin.column_count.times.to_a
+            idxs[a], idxs[b] = [b, a]
+            mat_builtin = Matrix::columns(mat_builtin.column_vectors.values_at(*idxs))
+          end
+          expect(mat_mod).to equal(mat[0])
           expect(mat[0].to_a).to eq(mat_builtin.to_a)
         }
       }