gps_pvt 0.6.2 → 0.7.0

data/ext/ninja-scan-light/tool/navigation/SP3.h

@@ -41,7 +41,6 @@
 #include <cstring>
 #include <map>
 #include <set>
-#include <algorithm>
 #include <stdexcept>
 
 #include "util/text_helper.h"
@@ -61,22 +60,15 @@ struct SP3_Product {
     typedef std::map<GPS_Time<FloatT>, prop_t> history_t;
     history_t pos_history;
     history_t vel_history;
-
-    static const struct interpolate_cnd_t {
-      std::size_t max_epochs; ///< maximum number of epochs used for interpolation
-      FloatT max_delta_t; ///< maximum acceptable absolute time difference between t and epoch
-    } interpolate_cnd_default;
+    
+    typedef InterpolatableSet<GPS_Time<FloatT>, prop_t, FloatT> interpolator_t;
+    typedef typename interpolator_t::condition_t interpolate_cnd_t;
+    static const interpolate_cnd_t interpolate_cnd_default;
 
     mutable struct {
-      struct target_t {
-
-        typedef typename std::vector<std::pair<GPS_Time<FloatT>, prop_t> > buf_t;
-        buf_t buf;
-        GPS_Time<FloatT> t0;
-        std::vector<FloatT> dt;
-        bool updated_full_cnd;
+      struct target_t : public interpolator_t {
 
-        target_t() : t0(0, 0), updated_full_cnd(false) {}
+        target_t() : interpolator_t() {}
 
         /**
          * update interpolation source
@@ -88,58 +80,13 @@ struct SP3_Product {
             const bool &force_update = false,
             const interpolate_cnd_t &cnd = interpolate_cnd_default){
 
-          FloatT t_diff(t0 - t);
-          if((!force_update)
-              && ((std::abs(t_diff) <= 10)
-                || ((dt.size() >= 2)
-                  && (std::abs(t_diff + dt[0]) <= std::abs(t_diff + dt[1])))) ){
-            return *this;
-          }
-
-          // If the 1st and 2nd nearest epochs are changed, then recalculate interpolation targets.
-          struct {
-            const GPS_Time<FloatT> &t_base;
-            bool operator()(
-                const typename history_t::value_type &rhs,
-                const typename history_t::value_type &lhs) const {
-              return std::abs(rhs.first - t_base) < std::abs(lhs.first - t_base);
-            }
-          } cmp = {(t0 = t)};
-
-          buf.resize(cnd.max_epochs);
-          dt.clear();
-          // extract t where t0-dt <= t <= t0+dt, then sort by ascending order of |t-t0|
-          for(typename buf_t::const_iterator
-                it(buf.begin()),
-                it_end(std::partial_sort_copy(
-                  history.lower_bound(t - cnd.max_delta_t),
-                  history.upper_bound(t + cnd.max_delta_t),
-                  buf.begin(), buf.end(), cmp));
-              it != it_end; ++it){
-            dt.push_back(it->first - t0);
-          }
-          updated_full_cnd = (dt.size() >= cnd.max_epochs);
-
+          if((!force_update) && (std::abs(t - interpolator_t::x0) <= 10)){return *this;}
+          interpolator_t::update(t, history, cnd, force_update);
           return *this;
         }
 
-        template <class Ty, class Ty_Array>
-        Ty interpolate(
-            const GPS_Time<FloatT> &t, const Ty_Array &y,
-            Ty *derivative = NULL) const {
-          int order(dt.size() - 1);
-          do{
-            if(order > 0){break;}
-            if((order == 0) && (!derivative)){return y[0];}
-            throw std::range_error("Insufficient records for interpolation");
-          }while(false);
-          std::vector<Ty> y_buf(order), dy_buf(order);
-          interpolate_Neville(
-              dt, y, t - t0, y_buf, order,
-              &dy_buf, derivative ? 1 : 0);
-          if(derivative){*derivative = dy_buf[0];}
-          return y_buf[0];
-        }
+        typedef typename interpolator_t::buffer_t buf_t;
+
         Vector3<FloatT> interpolate_xyz(
             const GPS_Time<FloatT> &t,
             Vector3<FloatT> *derivative = NULL) const {
@@ -149,8 +96,8 @@ struct SP3_Product {
             const Vector3<FloatT> &operator[](const int &n) const {
               return buf_t::const_iterator::operator[](n).second.xyz;
             }
-          } xyz(buf.begin());
-          return interpolate(t, xyz, derivative);
+          } xyz(interpolator_t::buf.begin());
+          return interpolator_t::interpolate2(t, xyz, derivative);
         }
         FloatT interpolate_clk(
             const GPS_Time<FloatT> &t,
@@ -161,8 +108,8 @@ struct SP3_Product {
             const FloatT &operator[](const int &n) const {
               return buf_t::const_iterator::operator[](n).second.clk;
             }
-          } clk(buf.begin());
-          return interpolate(t, clk, derivative);
+          } clk(interpolator_t::buf.begin());
+          return interpolator_t::interpolate2(t, clk, derivative);
         }
       } pos_clk, vel_rate;
     } subset;
@@ -175,7 +122,7 @@ struct SP3_Product {
     bool precheck(const GPS_Time<FloatT> &t) const {
       // Only position/clock is checked, because velocity/rate can be calculated based on pos/clk.
       subset.pos_clk.update(t, pos_history);
-      return subset.pos_clk.updated_full_cnd;
+      return subset.pos_clk.ready;
     }
 
     typename GPS_SpaceNode<FloatT>::SatelliteProperties::constellation_t
@@ -238,7 +185,7 @@ struct SP3_Product {
         }
       };
       typename GPS_Solver_Base<FloatT>::satellite_t res = {
-        this,
+        this, this,
         impl_t::position, impl_t::velocity,
         impl_t::clock_error, impl_t::clock_error_dot
       };
@@ -301,29 +248,33 @@ struct SP3_Product {
   }
 
   enum system_t {
-    SYSTEM_GPS      = (int)'\0' << 8,
-    SYSTEM_SBAS     = SYSTEM_GPS,
-    SYSTEM_QZSS     = SYSTEM_GPS,
-    SYSTEM_GLONASS  = (int)'R' << 8,
-    SYSTEM_LEO      = (int)'L' << 8,
-    SYSTEM_GALILEO  = (int)'E' << 8,
-    SYSTEM_BEIDOU   = (int)'C' << 8,
-    SYSTEM_IRNSS    = (int)'I' << 8,
+    SYSTEM_GPS,
+    SYSTEM_SBAS,
+    SYSTEM_QZSS,
+    SYSTEM_GLONASS,
+    SYSTEM_LEO,
+    SYSTEM_GALILEO,
+    SYSTEM_BEIDOU,
+    SYSTEM_IRNSS,
+    NUM_OF_SYSTEMS,
   };
 
-#define gen_func(sys) \
-static typename GPS_Solver_Base<FloatT>::satellite_t select_ ## sys( \
-    const void *ptr, const int &prn, const GPS_Time<FloatT> &receiver_time){ \
-  return reinterpret_cast<const SP3_Product<FloatT> *>(ptr) \
-      ->select(prn + SYSTEM_ ## sys, receiver_time); \
-}
-  gen_func(GPS);
-  gen_func(GLONASS);
-  gen_func(LEO);
-  gen_func(GALILEO);
-  gen_func(BEIDOU);
-  gen_func(IRNSS);
-#undef gen_fun
+  static const int offset_list[NUM_OF_SYSTEMS];
+
+  protected:
+
+  mutable struct per_system_t {
+    const SP3_Product<FloatT> *product;
+    system_t sys;
+  } per_system[NUM_OF_SYSTEMS];
+
+  static typename GPS_Solver_Base<FloatT>::satellite_t select(
+      const void *ptr, const int &prn, const GPS_Time<FloatT> &receiver_time){
+    const per_system_t *ptr_impl(reinterpret_cast<const per_system_t *>(ptr));
+    return ptr_impl->product->select((prn & 0xFF) + offset_list[ptr_impl->sys], receiver_time);
+  }
+
+  public:
 
   /**
    * push SP3 product to satellite selector
@@ -334,19 +285,11 @@ static typename GPS_Solver_Base<FloatT>::satellite_t select_ ## sys( \
    */
   template <class SelectorT>
   bool push(SelectorT &slct, const system_t &sys = SYSTEM_GPS) const {
-    switch(sys){
-      case SYSTEM_GPS: // SBAS and QZSS are identically treated as GPS.
-      //case SYSTEM_SBAS:
-      //case SYSTEM_QZSS:
-        slct.impl_select = select_GPS; break;
-      case SYSTEM_GLONASS:  slct.impl_select = select_GLONASS;  break;
-      case SYSTEM_LEO:      slct.impl_select = select_LEO;      break;
-      case SYSTEM_GALILEO:  slct.impl_select = select_GALILEO;  break;
-      case SYSTEM_BEIDOU:   slct.impl_select = select_BEIDOU;   break;
-      case SYSTEM_IRNSS:    slct.impl_select = select_IRNSS;    break;
-      default: return false;
-    }
-    slct.impl = this;
+    if(sys >= NUM_OF_SYSTEMS){return false;}
+    per_system[sys].product = this;
+    per_system[sys].sys = sys;
+    slct.impl_select = select;
+    slct.impl = &per_system[sys];
     return true;
   }
 
@@ -358,19 +301,19 @@ static typename GPS_Solver_Base<FloatT>::satellite_t select_ ## sys( \
     for(typename satellites_t::const_iterator
           it(satellites.begin()), it_end(satellites.end());
         it != it_end; ++it){
-      switch(it->first & 0xFF00){
-        case SYSTEM_GPS: {
+      switch((char)(it->first >> 8)){
+        case '\0': {
           int id(it->first & 0xFF);
           if(id < 100){++res.gps;}
           else if(id < 192){++res.sbas;}
           else{++res.qzss;}
           break;
         }
-        case SYSTEM_GLONASS:  ++res.glonass;  break;
-        case SYSTEM_LEO:      ++res.leo;      break;
-        case SYSTEM_GALILEO:  ++res.galileo;  break;
-        case SYSTEM_BEIDOU:   ++res.beidou;   break;
-        case SYSTEM_IRNSS:    ++res.irnss;    break;
+        case 'R': ++res.glonass;  break;
+        case 'L': ++res.leo;      break;
+        case 'E': ++res.galileo;  break;
+        case 'C': ++res.beidou;   break;
+        case 'I': ++res.irnss;    break;
         default: ++res.unknown; break;
       }
     }
@@ -381,10 +324,24 @@ static typename GPS_Solver_Base<FloatT>::satellite_t select_ ## sys( \
 template <class FloatT>
 const typename SP3_Product<FloatT>::per_satellite_t::interpolate_cnd_t
     SP3_Product<FloatT>::per_satellite_t::interpolate_cnd_default = {
-  9, // max_epochs
-  60 * 60 * 2, // max_delta_t, default is 2 hr = 15 min interval records; (2 hr * 2 / (9 - 1) = 15 min)
+  9, // maximum number of epochs used for interpolation
+  /* maximum acceptable absolute time difference between t and epoch,
+   * default is 2 hr = 15 min interval records; (2 hr * 2 / (9 - 1) = 15 min)
+   */
+  60 * 60 * 2,
+};
+
+template <class FloatT>
+const int SP3_Product<FloatT>::offset_list[NUM_OF_SYSTEMS] = {
+  0, 0, 0, // GPS, SBAS, QZSS
+  ((int)'R' << 8), // GLONASS
+  ((int)'L' << 8), // LEO
+  ((int)'E' << 8), // GALILEO
+  ((int)'C' << 8), // BEIDOU
+  ((int)'I' << 8), // IRNSS
 };
 
+
 template <class FloatT>
 class SP3_Reader {
   protected:

data/ext/ninja-scan-light/tool/param/quaternion.h

@@ -130,7 +130,7 @@ class QuaternionData : public QuaternionDataProperty<FloatT> {
      * @param q �R�s�[��
      */
     QuaternionData(const self_t &q){
-      if(storage = q.storage){(storage->ref)++;}
+      if((storage = q.storage)){(storage->ref)++;}
     }
     
     /**
@@ -143,7 +143,7 @@ class QuaternionData : public QuaternionDataProperty<FloatT> {
     self_t &operator=(const self_t &q){
       if(this == &q){return *this;}
       if(storage && ((--(storage->ref)) <= 0)){delete storage;}
-      if(storage = q.storage){(storage->ref)++;}
+      if((storage = q.storage)){(storage->ref)++;}
       return *this;
     }
     

data/ext/ninja-scan-light/tool/param/vector3.h

@@ -133,7 +133,7 @@ class Vector3Data : public Vector3DataProperty<FloatT> {
      * @param v �R�s�[��
      */
     Vector3Data(const self_t &v){
-      if(storage = v.storage){(storage->ref)++;}
+      if((storage = v.storage)){(storage->ref)++;}
     }
     
     /**
@@ -146,7 +146,7 @@ class Vector3Data : public Vector3DataProperty<FloatT> {
     self_t &operator=(const self_t &v){
       if(this == &v){return *this;}
       if(storage && ((--(storage->ref)) <= 0)){delete storage;}
-      if(storage = v.storage){(storage->ref)++;}
+      if((storage = v.storage)){(storage->ref)++;}
       return *this;
     }
     

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

@@ -22,6 +22,7 @@
 #include "navigation/QZSS.h"
 #include "navigation/GLONASS.h"
 #include "navigation/RINEX.h"
+#include "navigation/RINEX_Clock.h"
 #include "navigation/SP3.h"
 #include "navigation/ANTEX.h"
 
@@ -228,12 +229,10 @@ struct GPS_Ionospheric_UTC_Parameters : public GPS_SpaceNode<FloatT>::Ionospheri
 %}
 %extend GPS_Ionospheric_UTC_Parameters {
   %fragment(SWIG_Traits_frag(FloatT));
-  %typemap(in,numinputs=0) FloatT values[4] (FloatT temp[4]) %{
-    $1 = temp;
-  %}
-  %typemap(argout) FloatT values[4] {
+  %typemap(in,numinputs=0) const FloatT *values[4] (FloatT *temp) "$1 = &temp;"
+  %typemap(argout) const FloatT *values[4] {
     for(int i(0); i < 4; ++i){
-      %append_output(swig::from($1[i]));
+      %append_output(swig::from((*$1)[i]));
     }
   }
   MAKE_ARRAY_INPUT(const FloatT, values, swig::asval);
@@ -245,11 +244,7 @@ struct GPS_Ionospheric_UTC_Parameters : public GPS_SpaceNode<FloatT>::Ionospheri
     } 
   }
   %rename("alpha") get_alpha;
-  void get_alpha(FloatT values[4]) const {
-    for(int i(0); i < 4; ++i){
-      values[i] = self->alpha[i];
-    }
-  }
+  void get_alpha(const FloatT *values[4]) const {*values = self->alpha;}
   %rename("beta=") set_beta;
   void set_beta(const FloatT values[4]){
     for(int i(0); i < 4; ++i){
@@ -257,11 +252,7 @@ struct GPS_Ionospheric_UTC_Parameters : public GPS_SpaceNode<FloatT>::Ionospheri
     }
   }
   %rename("beta") get_beta;
-  void get_beta(FloatT values[4]) const {
-    for(int i(0); i < 4; ++i){
-      values[i] = self->beta[i];
-    }
-  }
+  void get_beta(const FloatT *values[4]) const {*values = self->beta;}
   MAKE_ACCESSOR(A1, FloatT);
   MAKE_ACCESSOR(A0, FloatT);
   MAKE_ACCESSOR(t_ot, unsigned int);
@@ -1006,6 +997,7 @@ const type &get_ ## name () const {
 %inline %{
 template <class FloatT>
 struct GPS_SolverOptions_Common {
+  virtual ~GPS_SolverOptions_Common() {}
   virtual GPS_Solver_GeneralOptions<FloatT> *cast_general() = 0;
   virtual const GPS_Solver_GeneralOptions<FloatT> *cast_general() const = 0;
 };
@@ -1206,7 +1198,10 @@ struct GPS_RangeCorrector
       if(!res.is_available()){
         static const VALUE key(ID2SYM(rb_intern("relative_property")));
         VALUE hook(rb_hash_lookup(hooks, key));
-        if(!NIL_P(hook)){res.impl = this;}
+        if(!NIL_P(hook)){
+          if(!res.impl_xyz){res.impl_xyz = this;}
+          if(!res.impl_t){res.impl_t = this;}
+        }
       }
 #endif
       return res;
@@ -1653,31 +1648,8 @@ template <class FloatT>
 struct RINEX_Observation {};
 }
 
-%extend SP3 {
-  %typemap(in,numinputs=0) int count[ANY] (int temp[$1_dim0]) "$1 = temp;"
-  %typemap(argout) int count[ANY] {
-    for(int i(0); i < $1_dim0; ++i){
-      %append_output(SWIG_From(int)($1[i]));
-    }
-  }
-  void satellites(int count[SP3::SYS_SYSTEMS]) const {
-    typename SP3_Product<FloatT>::satellite_count_t x(self->satellite_count());
-    count[SP3<FloatT>::SYS_GPS] = x.gps;
-    count[SP3<FloatT>::SYS_SBAS] = x.sbas;
-    count[SP3<FloatT>::SYS_QZSS] = x.qzss;
-    count[SP3<FloatT>::SYS_GLONASS] = x.glonass;
-    count[SP3<FloatT>::SYS_GALILEO] = x.galileo;
-    count[SP3<FloatT>::SYS_BEIDOU] = x.beidou;
-  }
-
-} 
 %inline {
-template <class FloatT>
-struct SP3 : public SP3_Product<FloatT> {
-  int read(const char *fname) {
-    std::fstream fin(fname, std::ios::in | std::ios::binary);
-    return SP3_Reader<FloatT>::read_all(fin, *this);
-  }
+struct PushableData {
   enum system_t {
     SYS_GPS,
     SYS_SBAS,
@@ -1687,20 +1659,21 @@ struct SP3 : public SP3_Product<FloatT> {
     SYS_BEIDOU,
     SYS_SYSTEMS,
   };
-  bool push(GPS_Solver<FloatT> &solver, const system_t &sys) const {
+  template <class DataT, class FloatT>
+  static bool push(DataT &data, GPS_Solver<FloatT> &solver, const system_t &sys){
     switch(sys){
       case SYS_GPS:
-        return SP3_Product<FloatT>::push(
-            solver.gps.ephemeris_proxy.gps, SP3_Product<FloatT>::SYSTEM_GPS);
+        return data.push(
+            solver.gps.ephemeris_proxy.gps, DataT::SYSTEM_GPS);
       case SYS_SBAS:
-        return SP3_Product<FloatT>::push(
-            solver.sbas.solver.satellites, SP3_Product<FloatT>::SYSTEM_SBAS);
+        return data.push(
+            solver.sbas.solver.satellites, DataT::SYSTEM_SBAS);
       case SYS_QZSS:
-        return SP3_Product<FloatT>::push(
-            solver.gps.ephemeris_proxy.qzss, SP3_Product<FloatT>::SYSTEM_QZSS);
+        return data.push(
+            solver.gps.ephemeris_proxy.qzss, DataT::SYSTEM_QZSS);
       case SYS_GLONASS:
-        return SP3_Product<FloatT>::push(
-            solver.glonass.solver.satellites, SP3_Product<FloatT>::SYSTEM_GLONASS);
+        return data.push(
+            solver.glonass.solver.satellites, DataT::SYSTEM_GLONASS);
       case SYS_GALILEO:
       case SYS_BEIDOU:
       default:
@@ -1708,7 +1681,8 @@ struct SP3 : public SP3_Product<FloatT> {
     }
     return false;
   }
-  bool push(GPS_Solver<FloatT> &solver) const {
+  template <class DataT, class FloatT>
+  static bool push(DataT &data, GPS_Solver<FloatT> &solver){
     system_t target[] = {
       SYS_GPS,
       SYS_SBAS,
@@ -1718,10 +1692,39 @@ struct SP3 : public SP3_Product<FloatT> {
       //SYS_BEIDOU,
     };
     for(std::size_t i(0); i < sizeof(target) / sizeof(target[0]); ++i){
-      if(!push(solver, target[i])){return false;}
+      if(!push(data, solver, target[i])){return false;}
     }
     return true;
   }
+};
+}
+
+%extend SP3 {
+  %typemap(out) typename SP3_Product<FloatT>::satellite_count_t {
+    %append_output(SWIG_From(int)($1.gps));
+    %append_output(SWIG_From(int)($1.sbas));
+    %append_output(SWIG_From(int)($1.qzss));
+    %append_output(SWIG_From(int)($1.glonass));
+    %append_output(SWIG_From(int)($1.galileo));
+    %append_output(SWIG_From(int)($1.beidou));
+  }
+}
+%inline {
+template <class FloatT>
+struct SP3 : public SP3_Product<FloatT>, PushableData {
+  int read(const char *fname) {
+    std::fstream fin(fname, std::ios::in | std::ios::binary);
+    return SP3_Reader<FloatT>::read_all(fin, *this);
+  }
+  typename SP3_Product<FloatT>::satellite_count_t satellites() const {
+    return SP3_Product<FloatT>::satellite_count();
+  }
+  bool push(GPS_Solver<FloatT> &solver, const PushableData::system_t &sys) const {
+    return PushableData::push((SP3_Product<FloatT> &)*this, solver, sys);
+  }
+  bool push(GPS_Solver<FloatT> &solver) const {
+    return PushableData::push((SP3_Product<FloatT> &)*this, solver);
+  }
   System_XYZ<FloatT, WGS84> position(
       const int &sat_id, const GPS_Time<FloatT> &t) const {
     return SP3_Product<FloatT>::select(sat_id, t).position(t);
@@ -1748,6 +1751,46 @@ struct SP3 : public SP3_Product<FloatT> {
 };
 }
 
+%extend RINEX_Clock {
+  %typemap(out) typename RINEX_CLK<FloatT>::satellites_t::count_t {
+    %append_output(SWIG_From(int)($1.gps));
+    %append_output(SWIG_From(int)($1.sbas));
+    %append_output(SWIG_From(int)($1.qzss));
+    %append_output(SWIG_From(int)($1.glonass));
+    %append_output(SWIG_From(int)($1.galileo));
+    %append_output(SWIG_From(int)($1.beidou));
+  }
+}
+%inline {
+template <class FloatT>
+struct RINEX_Clock : public RINEX_CLK<FloatT>::satellites_t, PushableData {
+  typedef typename RINEX_CLK<FloatT>::satellites_t super_t;
+  int read(const char *fname) {
+    std::fstream fin(fname, std::ios::in | std::ios::binary);
+    return RINEX_CLK_Reader<FloatT>::read_all(fin, *this);
+  }
+  typename RINEX_CLK<FloatT>::satellites_t::count_t satellites() const {
+    return RINEX_CLK<FloatT>::satellites_t::count();
+  }
+  bool push(GPS_Solver<FloatT> &solver, const PushableData::system_t &sys) const {
+    return PushableData::push((typename RINEX_CLK<FloatT>::satellites_t &)*this, solver, sys);
+  }
+  bool push(GPS_Solver<FloatT> &solver) const {
+    return PushableData::push((typename RINEX_CLK<FloatT>::satellites_t &)*this, solver);
+  }
+  FloatT clock_error(const int &sat_id, const GPS_Time<FloatT> &t) const {
+    typename super_t::buf_t::const_iterator it(this->buf.find(sat_id));
+    if(it == this->buf.end()){return super_t::sat_t::unavailable().clock_error(t);}
+    return it->second.clock_error(t);
+  }
+  FloatT clock_error_dot(const int &sat_id, const GPS_Time<FloatT> &t) const {
+    typename super_t::buf_t::const_iterator it(this->buf.find(sat_id));
+    if(it == this->buf.end()){return super_t::sat_t::unavailable().clock_error(t);}
+    return it->second.clock_error_dot(t);
+  }
+};
+}
+
 #undef MAKE_ACCESSOR
 #undef MAKE_VECTOR2ARRAY
 #undef MAKE_ARRAY_INPUT
@@ -1776,6 +1819,7 @@ struct SP3 : public SP3_Product<FloatT> {
 
 %template(RINEX_Observation) RINEX_Observation<type>;
 %template(SP3) SP3<type>;
+%template(RINEX_Clock) RINEX_Clock<type>;
 %enddef
 
 CONCRETIZE(double);

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

@@ -592,7 +592,6 @@ struct MatrixUtil {
       }
       static VALUE read(
           const VALUE &v, const unsigned int &row = 0, const unsigned int &column = 0) {
-        int state;
         VALUE values[3] = {v, UINT2NUM(row), UINT2NUM(column)};
         return funcall_throw_if_error(run, reinterpret_cast<VALUE>(values));
       }
@@ -865,7 +864,7 @@ struct MatrixUtil {
         static const ID with_index[] = {
             rb_intern("map_with_index"), rb_intern("map_with_index!"), 
             rb_intern("collect_with_index"), rb_intern("collect_with_index!")};
-        for(int i(0); i < sizeof(with_index) / sizeof(with_index[0]); ++i){
+        for(std::size_t i(0); i < sizeof(with_index) / sizeof(with_index[0]); ++i){
           if(id_callee == with_index[i]){
             return matrix_yield_get_with_index;
           }

data/gps_pvt.gemspec

@@ -53,6 +53,9 @@ Gem::Specification.new do |spec|
     }.flatten
   }.call
 
+  spec.rdoc_options << '--exclude=ext/ninja-scan-light'
+  spec.extra_rdoc_files = []
+
   # Uncomment to register a new dependency of your gem
   # spec.add_dependency "example-gem", "~> 1.0"
   spec.add_development_dependency "rake"

data/lib/gps_pvt/receiver.rb

@@ -410,7 +410,7 @@ class Receiver
               @solver.sbas_space_node.ionospheric_grid_points(prn)].each{|str|
             $stderr.puts str
           } if @debug[:SBAS_IGP] 
-        end
+        end if t_meas
       when :GLONASS
         next unless eph = eph_glonass_list[prn]
         leap_sec = @solver.gps_space_node.is_valid_utc ? 
@@ -508,10 +508,10 @@ class Receiver
           {
             :L1_PSEUDORANGE => [16, 8, "E", proc{|v| (trk_stat & 0x1 == 0x1) ? v : nil}],
             :L1_PSEUDORANGE_SIGMA => [43, 1, nil, proc{|v|
-              (trk_stat & 0x1 == 0x1) ? (1E-2 * (v[0] & 0xF)) : nil
+              (trk_stat & 0x1 == 0x1) ? (1E-2 * (1 << (v[0] & 0xF))) : nil
             }],
             :L1_DOPPLER => [32, 4, "e"],
-            :L1_DOPPLER_SIGMA => [45, 1, nil, proc{|v| 2E-3 * (v[0] & 0xF)}],
+            :L1_DOPPLER_SIGMA => [45, 1, nil, proc{|v| 2E-3 * (1 << (v[0] & 0xF))}],
             :L1_CARRIER_PHASE => [24, 8, "E", proc{|v| (trk_stat & 0x2 == 0x2) ? v : nil}],
             :L1_CARRIER_PHASE_SIGMA => [44, 1, nil, proc{|v|
               (trk_stat & 0x2 == 0x2) ? (0.004 * (v[0] & 0xF)) : nil
@@ -651,5 +651,21 @@ class Receiver
     raise "Format error! (Not ANTEX) #{src}" unless applied_items >= 0
     $stderr.puts "SP3 correction with ANTEX file (%s): %d items have been processed."%[src, applied_items]
   end
+  
+  def attach_rinex_clk(src)
+    fname = Util::get_txt(src)
+    @clk ||= GPS::RINEX_Clock::new
+    read_items = @clk.read(fname)
+    raise "Format error! (Not RINEX clock) #{src}" if read_items < 0
+    $stderr.puts "Read RINEX clock file (%s): %d items."%[src, read_items]
+    sats = @clk.satellites
+    @clk.class.constants.each{|sys|
+      next unless /^SYS_(?!SYSTEMS)(.*)/ =~ sys.to_s
+      idx, sys_name = [@clk.class.const_get(sys), $1]
+      next unless sats[idx] > 0
+      next unless @clk.push(@solver, idx)
+      $stderr.puts "Change clock error source of #{sys_name} to RINEX clock" 
+    }
+  end
 end
 end

data/lib/gps_pvt/version.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
-
-module GPS_PVT
-  VERSION = "0.6.2"
-end
+# frozen_string_literal: true
+
+module GPS_PVT
+  VERSION = "0.7.0"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gps_pvt
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.0
 platform: ruby
 authors:
 - fenrir(M.Naruoka)
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-08-03 00:00:00.000000000 Z
+date: 2022-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -44,6 +44,7 @@ email:
 - fenrir.naru@gmail.com
 executables:
 - gps_pvt
+- to_ubx
 extensions:
 - ext/gps_pvt/extconf.rb
 extra_rdoc_files: []
@@ -57,6 +58,7 @@ files:
 - bin/console
 - bin/setup
 - exe/gps_pvt
+- exe/to_ubx
 - ext/gps_pvt/Coordinate/Coordinate_wrap.cxx
 - ext/gps_pvt/GPS/GPS_wrap.cxx
 - ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx
@@ -76,6 +78,7 @@ files:
 - ext/ninja-scan-light/tool/navigation/NTCM.h
 - ext/ninja-scan-light/tool/navigation/QZSS.h
 - ext/ninja-scan-light/tool/navigation/RINEX.h
+- ext/ninja-scan-light/tool/navigation/RINEX_Clock.h
 - ext/ninja-scan-light/tool/navigation/SBAS.h
 - ext/ninja-scan-light/tool/navigation/SBAS_Solver.h
 - ext/ninja-scan-light/tool/navigation/SP3.h
@@ -109,7 +112,8 @@ metadata:
   homepage_uri: https://github.com/fenrir-naru/gps_pvt
   source_code_uri: https://github.com/fenrir-naru/gps_pvt
 post_install_message: 
-rdoc_options: []
+rdoc_options:
+- "--exclude=ext/ninja-scan-light"
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement