gps_pvt 0.8.0 → 0.8.2

data/ext/gps_pvt/GPS/GPS_wrap.cxx

@@ -1862,57 +1862,57 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
 #define SWIGTYPE_p_GPS_SolverOptionsT_double_t swig_types[12]
 #define SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t swig_types[13]
 #define SWIGTYPE_p_GPS_SolverT_double_t swig_types[14]
-#define SWIGTYPE_p_GPS_Solver_GeneralOptionsT_double_t swig_types[15]
-#define SWIGTYPE_p_GPS_SpaceNodeT_double_t swig_types[16]
-#define SWIGTYPE_p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters swig_types[17]
-#define SWIGTYPE_p_GPS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris swig_types[18]
-#define SWIGTYPE_p_GPS_TimeT_double_t swig_types[19]
-#define SWIGTYPE_p_GPS_TimeT_double_t__leap_second_event_t swig_types[20]
-#define SWIGTYPE_p_GPS_TimeT_double_t__leap_year_prop_res_t swig_types[21]
-#define SWIGTYPE_p_GPS_User_PVTT_double_t swig_types[22]
-#define SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t swig_types[23]
-#define SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t swig_types[24]
-#define SWIGTYPE_p_MatrixViewBaseT_t swig_types[25]
-#define SWIGTYPE_p_MatrixViewFilterT_MatrixViewBaseT_t_t swig_types[26]
-#define SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t swig_types[27]
-#define SWIGTYPE_p_PushableData swig_types[28]
-#define SWIGTYPE_p_RINEX_ClockT_double_t swig_types[29]
-#define SWIGTYPE_p_RINEX_ObservationT_double_t swig_types[30]
-#define SWIGTYPE_p_SBAS_EphemerisT_double_t swig_types[31]
-#define SWIGTYPE_p_SBAS_SolverOptionsT_double_t swig_types[32]
-#define SWIGTYPE_p_SBAS_SpaceNodeT_double_t swig_types[33]
-#define SWIGTYPE_p_SBAS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris swig_types[34]
-#define SWIGTYPE_p_SP3T_double_t swig_types[35]
-#define SWIGTYPE_p_System_ENUT_double_WGS84_t swig_types[36]
-#define SWIGTYPE_p_System_LLHT_double_WGS84_t swig_types[37]
-#define SWIGTYPE_p_System_XYZT_double_WGS84_t swig_types[38]
-#define SWIGTYPE_p_available_satellites_t swig_types[39]
-#define SWIGTYPE_p_char swig_types[40]
-#define SWIGTYPE_p_double swig_types[41]
-#define SWIGTYPE_p_enu_t swig_types[42]
-#define SWIGTYPE_p_eph_t swig_types[43]
-#define SWIGTYPE_p_float_t swig_types[44]
-#define SWIGTYPE_p_gps_space_node_t swig_types[45]
-#define SWIGTYPE_p_gps_time_t swig_types[46]
-#define SWIGTYPE_p_int swig_types[47]
-#define SWIGTYPE_p_int_t swig_types[48]
-#define SWIGTYPE_p_llh_t swig_types[49]
-#define SWIGTYPE_p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t swig_types[50]
-#define SWIGTYPE_p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t swig_types[51]
-#define SWIGTYPE_p_p_double swig_types[52]
-#define SWIGTYPE_p_range_correction_list_t swig_types[53]
-#define SWIGTYPE_p_s16_t swig_types[54]
-#define SWIGTYPE_p_s32_t swig_types[55]
-#define SWIGTYPE_p_s8_t swig_types[56]
-#define SWIGTYPE_p_satellites_t swig_types[57]
-#define SWIGTYPE_p_self_t swig_types[58]
-#define SWIGTYPE_p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t swig_types[59]
-#define SWIGTYPE_p_super_t swig_types[60]
-#define SWIGTYPE_p_swig__GC_VALUE swig_types[61]
-#define SWIGTYPE_p_u16_t swig_types[62]
-#define SWIGTYPE_p_u32_t swig_types[63]
-#define SWIGTYPE_p_u8_t swig_types[64]
-#define SWIGTYPE_p_uint_t swig_types[65]
+#define SWIGTYPE_p_GPS_SpaceNodeT_double_t swig_types[15]
+#define SWIGTYPE_p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters swig_types[16]
+#define SWIGTYPE_p_GPS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris swig_types[17]
+#define SWIGTYPE_p_GPS_TimeT_double_t swig_types[18]
+#define SWIGTYPE_p_GPS_TimeT_double_t__leap_second_event_t swig_types[19]
+#define SWIGTYPE_p_GPS_TimeT_double_t__leap_year_prop_res_t swig_types[20]
+#define SWIGTYPE_p_GPS_User_PVTT_double_t swig_types[21]
+#define SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t swig_types[22]
+#define SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t swig_types[23]
+#define SWIGTYPE_p_MatrixViewBaseT_t swig_types[24]
+#define SWIGTYPE_p_MatrixViewFilterT_MatrixViewBaseT_t_t swig_types[25]
+#define SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t swig_types[26]
+#define SWIGTYPE_p_PushableData swig_types[27]
+#define SWIGTYPE_p_RINEX_ClockT_double_t swig_types[28]
+#define SWIGTYPE_p_RINEX_ObservationT_double_t swig_types[29]
+#define SWIGTYPE_p_SBAS_EphemerisT_double_t swig_types[30]
+#define SWIGTYPE_p_SBAS_SolverOptionsT_double_t swig_types[31]
+#define SWIGTYPE_p_SBAS_SpaceNodeT_double_t swig_types[32]
+#define SWIGTYPE_p_SBAS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris swig_types[33]
+#define SWIGTYPE_p_SP3T_double_t swig_types[34]
+#define SWIGTYPE_p_System_ENUT_double_WGS84_t swig_types[35]
+#define SWIGTYPE_p_System_LLHT_double_WGS84_t swig_types[36]
+#define SWIGTYPE_p_System_XYZT_double_WGS84_t swig_types[37]
+#define SWIGTYPE_p_available_satellites_t swig_types[38]
+#define SWIGTYPE_p_char swig_types[39]
+#define SWIGTYPE_p_double swig_types[40]
+#define SWIGTYPE_p_enu_t swig_types[41]
+#define SWIGTYPE_p_eph_t swig_types[42]
+#define SWIGTYPE_p_float_t swig_types[43]
+#define SWIGTYPE_p_gps_space_node_t swig_types[44]
+#define SWIGTYPE_p_gps_time_t swig_types[45]
+#define SWIGTYPE_p_int swig_types[46]
+#define SWIGTYPE_p_int_t swig_types[47]
+#define SWIGTYPE_p_llh_t swig_types[48]
+#define SWIGTYPE_p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t swig_types[49]
+#define SWIGTYPE_p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t swig_types[50]
+#define SWIGTYPE_p_p_double swig_types[51]
+#define SWIGTYPE_p_range_correction_list_t swig_types[52]
+#define SWIGTYPE_p_s16_t swig_types[53]
+#define SWIGTYPE_p_s32_t swig_types[54]
+#define SWIGTYPE_p_s8_t swig_types[55]
+#define SWIGTYPE_p_satellites_t swig_types[56]
+#define SWIGTYPE_p_self_t swig_types[57]
+#define SWIGTYPE_p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t swig_types[58]
+#define SWIGTYPE_p_super_t swig_types[59]
+#define SWIGTYPE_p_swig__GC_VALUE swig_types[60]
+#define SWIGTYPE_p_u16_t swig_types[61]
+#define SWIGTYPE_p_u32_t swig_types[62]
+#define SWIGTYPE_p_u8_t swig_types[63]
+#define SWIGTYPE_p_uint_t swig_types[64]
+#define SWIGTYPE_p_unsigned_int swig_types[65]
 #define SWIGTYPE_p_xyz_t swig_types[66]
 static swig_type_info *swig_types[68];
 static swig_module_info swig_module = {swig_types, 67, 0, 0, 0, 0};
@@ -1964,6 +1964,7 @@ static VALUE mGPS;
 #include "navigation/GPS_Solver_Base.h"
 #include "navigation/GPS_Solver.h"
 #include "navigation/GPS_Solver_RAIM.h"
+#include "navigation/GPS_Solver_MultiFrequency.h"
 #include "navigation/SBAS_Solver.h"
 #include "navigation/GLONASS_Solver.h"
 
@@ -2360,6 +2361,11 @@ struct GPS_Ephemeris : public GPS_SpaceNode<FloatT>::SatelliteProperties::Epheme
         || (this->iode != this->iode_subframe3)
         || ((this->iodc & 0xFF) != this->iode));
   }
+  bool is_valid(const GPS_Time<FloatT> &t) const {
+    return is_consistent() && GPS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris::is_valid(t);
+  }
+  GPS_Time<FloatT> t_clock() const {return GPS_Time<FloatT>(this->WN, this->t_oc);}
+  GPS_Time<FloatT> t_ephemeris() const {return GPS_Time<FloatT>(this->WN, this->t_oe);}
   GPS_Ephemeris() : GPS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris() {
     invalidate();
   }
@@ -2381,6 +2387,10 @@ struct SBAS_Ephemeris : public SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephe
   SBAS_Ephemeris() : SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris() {}
   SBAS_Ephemeris(const typename SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris &eph) 
       : SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris(eph) {}
+  bool is_valid(const GPS_Time<FloatT> &t) const {
+    return SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris::is_valid(t);
+  }
+  GPS_Time<FloatT> t_applicable() const {return GPS_Time<FloatT>(this->WN, this->t_0);}
 };
 
 
@@ -2397,6 +2407,9 @@ struct GLONASS_Ephemeris
   bool is_consistent() const {
     return has_string == 0x1F;
   }
+  bool is_valid(const GPS_Time<FloatT> &t) const {
+    return is_consistent() && eph_t::is_valid(t);
+  }
   GLONASS_Ephemeris() : eph_t() {
     invalidate();
   }
@@ -2525,6 +2538,16 @@ struct GPS_Measurement {
     L1_SIGNAL_STRENGTH_dBHz,
     L1_LOCK_SEC,
     L1_FREQUENCY,
+
+
+    L2CM_PSEUDORANGE, L2CL_PSEUDORANGE, L2CM_PSEUDORANGE_SIGMA, L2CL_PSEUDORANGE_SIGMA,
+    L2CM_CARRIER_PHASE, L2CL_CARRIER_PHASE, L2CM_CARRIER_PHASE_SIGMA, L2CL_CARRIER_PHASE_SIGMA,
+    L2CM_DOPPLER, L2CL_DOPPLER, L2CM_DOPPLER_SIGMA, L2CL_DOPPLER_SIGMA,
+    L2CM_RANGE_RATE, L2CL_RANGE_RATE, L2CM_RANGE_RATE_SIGMA, L2CL_RANGE_RATE_SIGMA,
+    L2CM_SIGNAL_STRENGTH_dBHz, L2CL_SIGNAL_STRENGTH_dBHz,
+    L2CM_LOCK_SEC, L2CL_LOCK_SEC,
+
+
     ITEMS_PREDEFINED,
   };
   void add(const int &prn, const int &key, const FloatT &value){
@@ -2543,12 +2566,14 @@ struct GPS_SolverOptions_Common {
 
 template <class FloatT>
 struct GPS_SolverOptions 
-    : public GPS_SinglePositioning<FloatT>::options_t, 
+    : public GPS_Solver_MultiFrequency<GPS_SinglePositioning<FloatT> >::options_t, 
     GPS_SolverOptions_Common<FloatT> {
-  typedef typename GPS_SinglePositioning<FloatT>::options_t base_t;
+  typedef typename GPS_Solver_MultiFrequency<GPS_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();}
+  bool get_exclude_L2C() {return base_t::exclude_L2C;}
+  bool set_exclude_L2C(const bool &b) {return base_t::exclude_L2C = b;}
   GPS_Solver_GeneralOptions<FloatT> *cast_general(){return this;}
   const GPS_Solver_GeneralOptions<FloatT> *cast_general() const {return this;}
 };
@@ -2600,6 +2625,43 @@ struct GPS_RangeCorrector
 };
 
 
+template <class BaseT, class HookT>
+struct HookableSolver : public BaseT {
+  typedef BaseT base_t;
+  HookT *hook;
+  template <class ArgT>
+  HookableSolver(const ArgT &);
+  virtual typename base_t::relative_property_t relative_property(
+      const typename base_t::prn_t &prn,
+      const typename base_t::measurement_t::mapped_type &measurement,
+      const typename base_t::float_t &receiver_error,
+      const typename base_t::gps_time_t &time_arrival,
+      const typename base_t::pos_t &usr_pos,
+      const typename base_t::xyz_t &usr_vel) const {
+    typename base_t::relative_property_t res(
+        base_t::relative_property(
+          prn, measurement, receiver_error, time_arrival,
+          usr_pos, usr_vel));
+    if(hook){
+      res = hook->relative_property(
+          prn, measurement, receiver_error, time_arrival,
+          usr_pos, usr_vel,
+          res);
+    }
+    return res;
+  }
+  virtual typename base_t::satellite_t select_satellite(
+      const typename base_t::prn_t &prn,
+      const typename base_t::gps_time_t &time) const {
+    typename base_t::satellite_t res(base_t::select_satellite(prn, time));
+    if(hook){
+      res = hook->select_satellite(prn, time, res);
+    }
+    return res;
+  }
+};
+
+
 template <class FloatT>
 struct GPS_Solver 
     : public GPS_Solver_RAIM_LSR<FloatT, 
@@ -2610,7 +2672,9 @@ struct GPS_Solver
   struct gps_t {
     GPS_SpaceNode<FloatT> space_node;
     GPS_SolverOptions<FloatT> options;
-    GPS_SinglePositioning<FloatT> solver;
+    HookableSolver<
+        GPS_Solver_MultiFrequency<GPS_SinglePositioning<FloatT> >,
+        GPS_Solver<FloatT> > solver;
     struct ephemeris_proxy_t {
       struct item_t {
         const void *impl;
@@ -2632,18 +2696,20 @@ struct GPS_Solver
         solver.satellites.impl_select = forward;
       }
     } ephemeris_proxy;
-    gps_t() : space_node(), options(), solver(space_node), ephemeris_proxy(solver) {}
+    gps_t() : space_node(), options(), solver(space_node), ephemeris_proxy(solver) {
+      options.exclude_L2C = true;
+    }
   } gps;
   struct sbas_t {
     SBAS_SpaceNode<FloatT> space_node;
     SBAS_SolverOptions<FloatT> options;
-    SBAS_SinglePositioning<FloatT> solver;
+    HookableSolver<SBAS_SinglePositioning<FloatT>, GPS_Solver<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;
+    HookableSolver<GLONASS_SinglePositioning<FloatT>, GPS_Solver<FloatT> > solver;
     glonass_t() : space_node(), options(), solver(space_node) {}
   } glonass;
   VALUE hooks;
@@ -2679,6 +2745,9 @@ struct GPS_Solver
         = sbas.solver.tropospheric_correction
         = glonass.solver.tropospheric_correction
         = tropospheric;
+    gps.solver.hook = this;
+    sbas.solver.hook = this;
+    glonass.solver.hook = this;
   }
   GPS_SpaceNode<FloatT> &gps_space_node() {return gps.space_node;}
   GPS_SolverOptions<FloatT> &gps_options() {return gps.options;}
@@ -2686,28 +2755,44 @@ struct GPS_Solver
   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 base_t &select(
       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.
-    static const base_t dummy; 
-    return dummy;
+    return *this;
   }
+  // proxy of virtual functions
+  typename base_t::relative_property_t relative_property(
+      const typename base_t::prn_t &prn,
+      const typename base_t::measurement_t::mapped_type &measurement,
+      const typename base_t::float_t &receiver_error,
+      const typename base_t::gps_time_t &time_arrival,
+      const typename base_t::pos_t &usr_pos,
+      const typename base_t::xyz_t &usr_vel,
+      const typename base_t::relative_property_t &orig) const;
   virtual typename base_t::relative_property_t relative_property(
       const typename base_t::prn_t &prn,
       const typename base_t::measurement_t::mapped_type &measurement,
       const typename base_t::float_t &receiver_error,
       const typename base_t::gps_time_t &time_arrival,
       const typename base_t::pos_t &usr_pos,
-      const typename base_t::xyz_t &usr_vel) const;
+      const typename base_t::xyz_t &usr_vel) const {
+    return relative_property(
+        prn, measurement, receiver_error, time_arrival, usr_pos, usr_vel,
+        super_t::relative_property(
+          prn, measurement, receiver_error, time_arrival, usr_pos, usr_vel));
+  }
+  typename base_t::satellite_t select_satellite(
+      const typename base_t::prn_t &prn,
+      const typename base_t::gps_time_t &time,
+      const typename base_t::satellite_t &orig) const;
   virtual typename base_t::satellite_t select_satellite(
       const typename base_t::prn_t &prn,
-      const typename base_t::gps_time_t &time) const;
+      const typename base_t::gps_time_t &time) const {
+    return select_satellite(prn, time, super_t::select_satellite(prn, time));
+  }
   virtual bool update_position_solution(
       const typename base_t::geometric_matrices_t &geomat,
       typename base_t::user_pvt_t &res) const;
@@ -3565,6 +3650,13 @@ SWIGINTERN GPS_Ionospheric_UTC_Parameters< double > GPS_Ionospheric_UTC_Paramete
     (typename GPS_SpaceNode<double>::Ionospheric_UTC_Parameters &)res = raw;
     return res;
   }
+SWIGINTERN void GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__dump(GPS_Ionospheric_UTC_Parameters< double > *self,unsigned int buf_brdc[10],GPS_Time< double > const &t){
+    typedef typename GPS_SpaceNode<double>
+        ::BroadcastedMessage<unsigned int, 30> dump_t;
+    dump_t::how_set(buf_brdc, t);
+    GPS_SpaceNode<double>::Ionospheric_UTC_Parameters::raw_t raw;
+    (raw = *self).dump<2, 0>(buf_brdc);
+  }
 SWIGINTERN unsigned int GPS_Ephemeris_Sl_double_Sg__set_svid(GPS_Ephemeris< double > *self,unsigned int const &v){
   return self->svid = v;
 }
@@ -3577,10 +3669,10 @@ SWIGINTERN unsigned int GPS_Ephemeris_Sl_double_Sg__set_WN(GPS_Ephemeris< double
 SWIGINTERN unsigned int const &GPS_Ephemeris_Sl_double_Sg__get_WN(GPS_Ephemeris< double > const *self){
   return self->WN;
 }
-SWIGINTERN int GPS_Ephemeris_Sl_double_Sg__set_URA(GPS_Ephemeris< double > *self,int const &v){
+SWIGINTERN double GPS_Ephemeris_Sl_double_Sg__set_URA(GPS_Ephemeris< double > *self,double const &v){
   return self->URA = v;
 }
-SWIGINTERN int const &GPS_Ephemeris_Sl_double_Sg__get_URA(GPS_Ephemeris< double > const *self){
+SWIGINTERN double const &GPS_Ephemeris_Sl_double_Sg__get_URA(GPS_Ephemeris< double > const *self){
   return self->URA;
 }
 SWIGINTERN unsigned int GPS_Ephemeris_Sl_double_Sg__set_SV_health(GPS_Ephemeris< double > *self,unsigned int const &v){
@@ -3783,6 +3875,62 @@ SWIGINTERN void GPS_Ephemeris_Sl_double_Sg__parse(GPS_Ephemeris< double > *self,
         break;
     }
   }
+SWIGINTERN void GPS_Ephemeris_Sl_double_Sg__dump(GPS_Ephemeris< double > *self,unsigned int buf_sf1[10],unsigned int buf_sf2[10],unsigned int buf_sf3[10],GPS_Time< double > const &t){
+    typedef typename GPS_SpaceNode<double>
+        ::BroadcastedMessage<unsigned int, 30> dump_t;
+    GPS_SpaceNode<double>::SatelliteProperties::Ephemeris::raw_t raw;
+    raw = *self;
+    unsigned int *buf[10] = {buf_sf1, buf_sf2, buf_sf3};
+    for(int i(0); i < 3; ++i){
+      dump_t::how_set(buf[i], t);
+      raw.dump<2, 0>(buf[i], i + 1);
+    }
+  }
+SWIGINTERN int GPS_Ephemeris_Sl_double_Sg__parse_almanac(GPS_Ephemeris< double > *self,unsigned int const buf[10]){
+    typedef GPS_SpaceNode<double>::BroadcastedMessage<unsigned int, 30> parse_t;
+    switch(parse_t::subframe_id(buf)){
+      case 4:
+      case 5:
+        break;
+      default: return -1;
+    }
+    typedef GPS_SpaceNode<double>::SatelliteProperties::Almanac almanac_t;
+    almanac_t::raw_t raw;
+    switch(parse_t::data_id(buf)){
+      case 1: // GPS
+        raw.update<2, 0>(buf);
+        if((raw.svid < 1) || (raw.svid > 32)){return -1;}
+        break;
+      case 3: // QZSS
+        reinterpret_cast<QZSS_SpaceNode<double>::SatelliteProperties::Almanac::raw_t &>(raw)
+            .update<2, 0>(buf);
+        if((raw.svid < 193) || (raw.svid > 202)){return -1;}
+        break;
+      default:
+        return -1;
+    }
+    almanac_t almanac;
+    *self = (GPS_SpaceNode<double>::SatelliteProperties::Ephemeris)(almanac = raw);
+    return self->svid;
+  }
+SWIGINTERN void GPS_Ephemeris_Sl_double_Sg__dump_almanac__SWIG_0(GPS_Ephemeris< double > *self,unsigned int buf_brdc[10],GPS_Time< double > const &t,unsigned int const &qzss_subframe=0){
+    typedef typename GPS_SpaceNode<double>
+        ::BroadcastedMessage<unsigned int, 30> dump_t;
+    dump_t::how_set(buf_brdc, t);
+    typedef GPS_SpaceNode<double>::SatelliteProperties::Almanac almanac_t;
+    almanac_t almanac;
+    almanac_t::raw_t raw;
+    raw = (almanac = *self);
+    switch(qzss_subframe){
+      case 4:
+      case 5:
+        reinterpret_cast<QZSS_SpaceNode<double>::SatelliteProperties::Almanac::raw_t &>(raw)
+            .dump<2, 0>(buf_brdc, qzss_subframe);
+        break;
+      default:
+        raw.dump<2, 0>(buf_brdc);
+    }
+  }
 SWIGINTERN GPS_Ephemeris< double >::constellation_res_t GPS_Ephemeris_Sl_double_Sg__constellation__SWIG_0(GPS_Ephemeris< double > const *self,GPS_Time< double > const &t_tx,double const &dt_transit=0){
     typename GPS_SpaceNode<double>::SatelliteProperties::constellation_t pv(
         self->constellation(t_tx, dt_transit, true));
@@ -3926,6 +4074,20 @@ SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_residual_mas
   return self->cast_general()->residual_mask;
 }
 
+    template <> template <>
+    HookableSolver<
+          GPS_Solver_MultiFrequency<GPS_SinglePositioning<double> >,
+          GPS_Solver<double> >
+        ::HookableSolver<GPS_SpaceNode<double> >(const GPS_SpaceNode<double> &sn)
+          : GPS_Solver_MultiFrequency<GPS_SinglePositioning<double> >(sn), hook(NULL) {}
+    template <> template <>
+    HookableSolver<SBAS_SinglePositioning<double>, GPS_Solver<double> >
+        ::HookableSolver<SBAS_SpaceNode<double> >(const SBAS_SpaceNode<double> &sn)
+          : SBAS_SinglePositioning<double>(sn), hook(NULL) {}
+    template <> template <>
+    HookableSolver<GLONASS_SinglePositioning<double>, GPS_Solver<double> >
+        ::HookableSolver<GLONASS_SpaceNode<double> >(const GLONASS_SpaceNode<double> &sn)
+          : GLONASS_SinglePositioning<double>(sn), hook(NULL) {}
     template <>
     GPS_Solver<double>::base_t::relative_property_t
         GPS_Solver<double>::relative_property(
@@ -3934,14 +4096,12 @@ SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_residual_mas
           const GPS_Solver<double>::base_t::float_t &receiver_error,
           const GPS_Solver<double>::base_t::gps_time_t &time_arrival,
           const GPS_Solver<double>::base_t::pos_t &usr_pos,
-          const GPS_Solver<double>::base_t::xyz_t &usr_vel) const {
+          const GPS_Solver<double>::base_t::xyz_t &usr_vel,
+          const GPS_Solver<double>::base_t::relative_property_t &res_orig) const {
       union {
         base_t::relative_property_t prop;
         double values[7];
-      } res = {
-          select_solver(prn).relative_property(
-            prn, measurement, receiver_error, time_arrival,
-            usr_pos, usr_vel)};
+      } res = {res_orig};
 
       do{
         static const VALUE key(ID2SYM(rb_intern("relative_property")));
@@ -4021,9 +4181,9 @@ SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_residual_mas
     template <>
     GPS_Solver<double>::base_t::satellite_t GPS_Solver<double>::select_satellite(
         const GPS_Solver<double>::base_t::prn_t &prn,
-        const GPS_Solver<double>::base_t::gps_time_t &time) const {
-      GPS_Solver<double>::base_t::satellite_t res(
-          select_solver(prn).select_satellite(prn, time));
+        const GPS_Solver<double>::base_t::gps_time_t &time,
+        const GPS_Solver<double>::base_t::satellite_t &res_orig) const {
+      GPS_Solver<double>::base_t::satellite_t res(res_orig);
 
       if(!res.is_available()){
         static const VALUE key(ID2SYM(rb_intern("relative_property")));
@@ -4280,6 +4440,12 @@ SWIGINTERN double SBAS_Ephemeris_Sl_double_Sg__set_a_Gf1(SBAS_Ephemeris< double
 SWIGINTERN double const &SBAS_Ephemeris_Sl_double_Sg__get_a_Gf1(SBAS_Ephemeris< double > const *self){
   return self->a_Gf1;
 }
+SWIGINTERN void SBAS_Ephemeris_Sl_double_Sg__dump__SWIG_0(SBAS_Ephemeris< double > *self,unsigned int buf_brdc[8],unsigned int const &preamble_idx=0){
+    SBAS_SpaceNode<double>::DataBlock::preamble_set2(buf_brdc, preamble_idx);
+    SBAS_SpaceNode<double>::SatelliteProperties::Ephemeris::raw_t raw;
+    (raw = *self).dump(buf_brdc);
+    SBAS_SpaceNode<double>::DataBlock::parity_set(buf_brdc);
+  }
 SWIGINTERN GPS_Ephemeris< double >::constellation_res_t SBAS_Ephemeris_Sl_double_Sg__constellation__SWIG_0(SBAS_Ephemeris< double > const *self,GPS_Time< double > const &t_tx,double const &dt_transit=0,bool const &with_velocity=true){
     typename SBAS_SpaceNode<double>::SatelliteProperties::constellation_t pv(
         self->constellation(t_tx, dt_transit, with_velocity));
@@ -4543,6 +4709,15 @@ SWIGINTERN bool GLONASS_Ephemeris_Sl_double_Sg__parse__SWIG_0(GLONASS_Ephemeris<
     self->has_string = has_string;
     return updated;
   }
+SWIGINTERN void GLONASS_Ephemeris_Sl_double_Sg__dump(GLONASS_Ephemeris< double > *self,unsigned int buf_str1[3],unsigned int buf_str2[3],unsigned int buf_str3[3],unsigned int buf_str4[3],unsigned int buf_str5[3],GPS_Time< double > const &t){
+    typename GLONASS_Ephemeris<double>::eph_t::raw_t raw;
+    raw = *self;
+    unsigned int *buf[4] = {buf_str1, buf_str2, buf_str3, buf_str4};
+    for(int i(0); i < 4; ++i){
+      raw.GLONASS_Ephemeris<double>::Ephemeris::raw_t::dump<0, 0>(buf[i], i + 1);
+    }
+    raw.GLONASS_Ephemeris<double>::TimeProperties::raw_t::dump<0, 0>(buf_str5);
+  }
 SWIGINTERN GPS_Ephemeris< double >::constellation_res_t GLONASS_Ephemeris_Sl_double_Sg__constellation__SWIG_0(GLONASS_Ephemeris< double > const *self,GPS_Time< double > const &t_tx,double const &dt_transit=0){
     typename GPS_SpaceNode<double>::SatelliteProperties::constellation_t pv(
         self->constellation(t_tx, dt_transit));
@@ -10872,6 +11047,67 @@ fail:
 }
 
 
+/*
+  Document-method: GPS_PVT::GPS::Ionospheric_UTC_Parameters.dump
+
+  call-seq:
+    dump(Time t)
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_Ionospheric_UTC_Parameters_dump(int argc, VALUE *argv, VALUE self) {
+  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< double > *) 0 ;
+  unsigned int *arg2 ;
+  GPS_Time< double > *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int temp2[10] = {
+    0
+  } ;
+  void *argp3 ;
+  int res3 = 0 ;
+  VALUE vresult = Qnil;
+  
+  arg2 = temp2;
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_Ionospheric_UTC_ParametersT_double_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > *","dump", 1, self )); 
+  }
+  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< double > * >(argp1);
+  res3 = SWIG_ConvertPtr(argv[0], &argp3, SWIGTYPE_p_GPS_TimeT_double_t,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "GPS_Time< double > const &","dump", 3, argv[0] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","dump", 3, argv[0])); 
+  }
+  arg3 = reinterpret_cast< GPS_Time< double > * >(argp3);
+  {
+    try {
+      GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__dump(arg1,arg2,(GPS_Time< double > const &)*arg3);
+    } catch (const native_exception &e) {
+      e.regenerate();
+      SWIG_fail;
+    } catch (const std::exception& e) {
+      SWIG_exception_fail(SWIG_RuntimeError, e.what());
+    }
+  }
+  {
+    for(int i(0); i < 10; ++i){
+      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int  ((arg2)[i]));
+    }
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
 _wrap_Ionospheric_UTC_Parameters_allocate(VALUE self)
@@ -11087,6 +11323,143 @@ fail:
 }
 
 
+/*
+  Document-method: GPS_PVT::GPS::Ephemeris.valid?
+
+  call-seq:
+    valid?(Time t) -> bool
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_Ephemeris_validq___(int argc, VALUE *argv, VALUE self) {
+  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
+  GPS_Time< double > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_EphemerisT_double_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","is_valid", 1, self )); 
+  }
+  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPS_TimeT_double_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_Time< double > const &","is_valid", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","is_valid", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
+  {
+    try {
+      result = (bool)((GPS_Ephemeris< double > const *)arg1)->is_valid((GPS_Time< double > const &)*arg2);
+    } catch (const native_exception &e) {
+      e.regenerate();
+      SWIG_fail;
+    } catch (const std::exception& e) {
+      SWIG_exception_fail(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+/*
+  Document-method: GPS_PVT::GPS::Ephemeris.t_clock
+
+  call-seq:
+    t_clock -> Time
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_Ephemeris_t_clock(int argc, VALUE *argv, VALUE self) {
+  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  GPS_Time< double > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_EphemerisT_double_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","t_clock", 1, self )); 
+  }
+  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
+  {
+    try {
+      result = ((GPS_Ephemeris< double > const *)arg1)->t_clock();
+    } catch (const native_exception &e) {
+      e.regenerate();
+      SWIG_fail;
+    } catch (const std::exception& e) {
+      SWIG_exception_fail(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_NewPointerObj((new GPS_Time< double >(static_cast< const GPS_Time< double >& >(result))), SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+/*
+  Document-method: GPS_PVT::GPS::Ephemeris.t_ephemeris
+
+  call-seq:
+    t_ephemeris -> Time
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_Ephemeris_t_ephemeris(int argc, VALUE *argv, VALUE self) {
+  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  GPS_Time< double > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_EphemerisT_double_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","t_ephemeris", 1, self )); 
+  }
+  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
+  {
+    try {
+      result = ((GPS_Ephemeris< double > const *)arg1)->t_ephemeris();
+    } catch (const native_exception &e) {
+      e.regenerate();
+      SWIG_fail;
+    } catch (const std::exception& e) {
+      SWIG_exception_fail(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_NewPointerObj((new GPS_Time< double >(static_cast< const GPS_Time< double >& >(result))), SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 /*
   Document-method: GPS_PVT::GPS::Ephemeris.new
 
@@ -11395,7 +11768,7 @@ fail:
   Document-method: GPS_PVT::GPS::Ephemeris.URA=
 
   call-seq:
-    URA=(int const & v) -> int
+    URA=(double const & v) -> double
 
 An instance method.
 
@@ -11403,13 +11776,13 @@ An instance method.
 SWIGINTERN VALUE
 _wrap_Ephemeris_URAe___(int argc, VALUE *argv, VALUE self) {
   GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
-  int *arg2 = 0 ;
+  double *arg2 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  int temp2 ;
-  int val2 ;
+  double temp2 ;
+  double val2 ;
   int ecode2 = 0 ;
-  int result;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 1) || (argc > 1)) {
@@ -11420,15 +11793,15 @@ _wrap_Ephemeris_URAe___(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_URA", 1, self )); 
   }
   arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
-  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","set_URA", 2, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_URA", 2, argv[0] ));
   } 
-  temp2 = static_cast< int >(val2);
+  temp2 = static_cast< double >(val2);
   arg2 = &temp2;
   {
     try {
-      result = (int)GPS_Ephemeris_Sl_double_Sg__set_URA(arg1,(int const &)*arg2);
+      result = (double)GPS_Ephemeris_Sl_double_Sg__set_URA(arg1,(double const &)*arg2);
     } catch (const native_exception &e) {
       e.regenerate();
       SWIG_fail;
@@ -11436,7 +11809,7 @@ _wrap_Ephemeris_URAe___(int argc, VALUE *argv, VALUE self) {
       SWIG_exception_fail(SWIG_RuntimeError, e.what());
     }
   }
-  vresult = SWIG_From_int(static_cast< int >(result));
+  vresult = SWIG_From_double(static_cast< double >(result));
   return vresult;
 fail:
   return Qnil;
@@ -11447,7 +11820,7 @@ fail:
   Document-method: GPS_PVT::GPS::Ephemeris.URA
 
   call-seq:
-    URA -> int const &
+    URA -> double const &
 
 An instance method.
 
@@ -11457,7 +11830,7 @@ _wrap_Ephemeris_URA(int argc, VALUE *argv, VALUE self) {
   GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  int *result = 0 ;
+  double *result = 0 ;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -11470,7 +11843,7 @@ _wrap_Ephemeris_URA(int argc, VALUE *argv, VALUE self) {
   arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
   {
     try {
-      result = (int *) &GPS_Ephemeris_Sl_double_Sg__get_URA((GPS_Ephemeris< double > const *)arg1);
+      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_URA((GPS_Ephemeris< double > const *)arg1);
     } catch (const native_exception &e) {
       e.regenerate();
       SWIG_fail;
@@ -11478,7 +11851,7 @@ _wrap_Ephemeris_URA(int argc, VALUE *argv, VALUE self) {
       SWIG_exception_fail(SWIG_RuntimeError, e.what());
     }
   }
-  vresult = SWIG_From_int(static_cast< int >(*result));
+  vresult = SWIG_From_double(static_cast< double >(*result));
   return vresult;
 fail:
   return Qnil;
@@ -13910,29 +14283,345 @@ fail:
 
 
 /*
-  Document-method: GPS_PVT::GPS::Ephemeris.constellation
+  Document-method: GPS_PVT::GPS::Ephemeris.dump
 
   call-seq:
-    constellation(Time t_tx, double const & dt_transit=0) -> GPS_Ephemeris< double >::constellation_res_t
-    constellation(Time t_tx) -> GPS_Ephemeris< double >::constellation_res_t
+    dump(Time t)
 
 An instance method.
 
 */
 SWIGINTERN VALUE
-_wrap_Ephemeris_constellation__SWIG_0(int argc, VALUE *argv, VALUE self) {
+_wrap_Ephemeris_dump(int argc, VALUE *argv, VALUE self) {
   GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
-  GPS_Time< double > *arg2 = 0 ;
-  double *arg3 = 0 ;
+  unsigned int *arg2 ;
+  unsigned int *arg3 ;
+  unsigned int *arg4 ;
+  GPS_Time< double > *arg5 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  void *argp2 ;
-  int res2 = 0 ;
-  double temp3 ;
-  double val3 ;
-  int ecode3 = 0 ;
-  GPS_Ephemeris< double >::constellation_res_t result;
-  VALUE vresult = Qnil;
+  unsigned int temp2[10] = {
+    0
+  } ;
+  unsigned int temp3[10] = {
+    0
+  } ;
+  unsigned int temp4[10] = {
+    0
+  } ;
+  void *argp5 ;
+  int res5 = 0 ;
+  VALUE vresult = Qnil;
+  
+  arg2 = temp2;
+  arg3 = temp3;
+  arg4 = temp4;
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_EphemerisT_double_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","dump", 1, self )); 
+  }
+  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
+  res5 = SWIG_ConvertPtr(argv[0], &argp5, SWIGTYPE_p_GPS_TimeT_double_t,  0 );
+  if (!SWIG_IsOK(res5)) {
+    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "GPS_Time< double > const &","dump", 5, argv[0] )); 
+  }
+  if (!argp5) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","dump", 5, argv[0])); 
+  }
+  arg5 = reinterpret_cast< GPS_Time< double > * >(argp5);
+  {
+    try {
+      GPS_Ephemeris_Sl_double_Sg__dump(arg1,arg2,arg3,arg4,(GPS_Time< double > const &)*arg5);
+    } catch (const native_exception &e) {
+      e.regenerate();
+      SWIG_fail;
+    } catch (const std::exception& e) {
+      SWIG_exception_fail(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = rb_ary_new();
+  {
+    for(int i(0); i < 10; ++i){
+      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int  ((arg2)[i]));
+    }
+  }
+  {
+    for(int i(0); i < 10; ++i){
+      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int  ((arg3)[i]));
+    }
+  }
+  {
+    for(int i(0); i < 10; ++i){
+      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int  ((arg4)[i]));
+    }
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+/*
+  Document-method: GPS_PVT::GPS::Ephemeris.parse_almanac
+
+  call-seq:
+    parse_almanac(unsigned int const [10] buf) -> int
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_Ephemeris_parse_almanac(int argc, VALUE *argv, VALUE self) {
+  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
+  unsigned int *arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int temp2[10] ;
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_EphemerisT_double_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","parse_almanac", 1, self )); 
+  }
+  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
+  {
+    if(!(RB_TYPE_P(argv[0], T_ARRAY) && (RARRAY_LEN(argv[0]) == 10))){
+      SWIG_exception(SWIG_TypeError, "array[10] is expected");
+    }
+    for(int i(0); i < 10; ++i){
+      if(!SWIG_IsOK(SWIG_AsVal_unsigned_SS_int (RARRAY_AREF(argv[0], i), &temp2[i]))){
+        SWIG_exception(SWIG_TypeError, "unsigned int is expected");
+      }
+    }
+    arg2 = temp2;
+  }
+  {
+    try {
+      result = (int)GPS_Ephemeris_Sl_double_Sg__parse_almanac(arg1,(unsigned int const (*))arg2);
+    } catch (const native_exception &e) {
+      e.regenerate();
+      SWIG_fail;
+    } catch (const std::exception& e) {
+      SWIG_exception_fail(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+/*
+  Document-method: GPS_PVT::GPS::Ephemeris.dump_almanac
+
+  call-seq:
+    dump_almanac(Time t, unsigned int const & qzss_subframe=0)
+    dump_almanac(Time t)
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_Ephemeris_dump_almanac__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
+  unsigned int *arg2 ;
+  GPS_Time< double > *arg3 = 0 ;
+  unsigned int *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int temp2[10] = {
+    0
+  } ;
+  void *argp3 ;
+  int res3 = 0 ;
+  unsigned int temp4 ;
+  unsigned int val4 ;
+  int ecode4 = 0 ;
+  VALUE vresult = Qnil;
+  
+  arg2 = temp2;
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_EphemerisT_double_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","dump_almanac", 1, self )); 
+  }
+  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
+  res3 = SWIG_ConvertPtr(argv[0], &argp3, SWIGTYPE_p_GPS_TimeT_double_t,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "GPS_Time< double > const &","dump_almanac", 3, argv[0] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","dump_almanac", 3, argv[0])); 
+  }
+  arg3 = reinterpret_cast< GPS_Time< double > * >(argp3);
+  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[1], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","dump_almanac", 4, argv[1] ));
+  } 
+  temp4 = static_cast< unsigned int >(val4);
+  arg4 = &temp4;
+  {
+    try {
+      GPS_Ephemeris_Sl_double_Sg__dump_almanac__SWIG_0(arg1,arg2,(GPS_Time< double > const &)*arg3,(unsigned int const &)*arg4);
+    } catch (const native_exception &e) {
+      e.regenerate();
+      SWIG_fail;
+    } catch (const std::exception& e) {
+      SWIG_exception_fail(SWIG_RuntimeError, e.what());
+    }
+  }
+  {
+    for(int i(0); i < 10; ++i){
+      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int  ((arg2)[i]));
+    }
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Ephemeris_dump_almanac__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
+  unsigned int *arg2 ;
+  GPS_Time< double > *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int temp2[10] = {
+    0
+  } ;
+  void *argp3 ;
+  int res3 = 0 ;
+  VALUE vresult = Qnil;
+  
+  arg2 = temp2;
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_EphemerisT_double_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","dump_almanac", 1, self )); 
+  }
+  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
+  res3 = SWIG_ConvertPtr(argv[0], &argp3, SWIGTYPE_p_GPS_TimeT_double_t,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "GPS_Time< double > const &","dump_almanac", 3, argv[0] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","dump_almanac", 3, argv[0])); 
+  }
+  arg3 = reinterpret_cast< GPS_Time< double > * >(argp3);
+  {
+    try {
+      GPS_Ephemeris_Sl_double_Sg__dump_almanac__SWIG_0(arg1,arg2,(GPS_Time< double > const &)*arg3);
+    } catch (const native_exception &e) {
+      e.regenerate();
+      SWIG_fail;
+    } catch (const std::exception& e) {
+      SWIG_exception_fail(SWIG_RuntimeError, e.what());
+    }
+  }
+  {
+    for(int i(0); i < 10; ++i){
+      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int  ((arg2)[i]));
+    }
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_Ephemeris_dump_almanac(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 4) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_EphemerisT_double_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_NO_NULL);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Ephemeris_dump_almanac__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_EphemerisT_double_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_NO_NULL);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_Ephemeris_dump_almanac__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "dump_almanac", 
+    "    void dump_almanac(unsigned int buf_brdc[10], GPS_Time< double > const &t, unsigned int const &qzss_subframe)\n"
+    "    void dump_almanac(unsigned int buf_brdc[10], GPS_Time< double > const &t)\n");
+  
+  return Qnil;
+}
+
+
+/*
+  Document-method: GPS_PVT::GPS::Ephemeris.constellation
+
+  call-seq:
+    constellation(Time t_tx, double const & dt_transit=0) -> GPS_Ephemeris< double >::constellation_res_t
+    constellation(Time t_tx) -> GPS_Ephemeris< double >::constellation_res_t
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_Ephemeris_constellation__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
+  GPS_Time< double > *arg2 = 0 ;
+  double *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  double temp3 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  GPS_Ephemeris< double >::constellation_res_t result;
+  VALUE vresult = Qnil;
   
   if ((argc < 2) || (argc > 2)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
@@ -15751,196 +16440,376 @@ fail:
 
 
 /*
-  Document-method: GPS_PVT::GPS::PVT.fde_2nd
+  Document-method: GPS_PVT::GPS::PVT.fde_2nd
+
+  call-seq:
+    fde_2nd
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_PVT_fde_2nd(int argc, VALUE *argv, VALUE self) {
+  GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
+  GPS_User_PVT< double >::base_t::detection_t **arg2 = (GPS_User_PVT< double >::base_t::detection_t **) 0 ;
+  GPS_User_PVT< double >::base_t::exclusion_t **arg3 = (GPS_User_PVT< double >::base_t::exclusion_t **) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  GPS_User_PVT< double >::base_t::detection_t *temp2 ;
+  GPS_User_PVT< double >::base_t::exclusion_t *temp3 ;
+  VALUE vresult = Qnil;
+  
+  {
+    arg2 = &temp2;
+  }
+  {
+    arg3 = &temp3;
+  }
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_User_PVTT_double_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","fde_2nd", 1, self )); 
+  }
+  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
+  {
+    try {
+      ((GPS_User_PVT< double > const *)arg1)->fde_2nd((GPS_User_PVT< double >::base_t::detection_t const **)arg2,(GPS_User_PVT< double >::base_t::exclusion_t const **)arg3);
+    } catch (const native_exception &e) {
+      e.regenerate();
+      SWIG_fail;
+    } catch (const std::exception& e) {
+      SWIG_exception_fail(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = rb_ary_new();
+  {
+    if((*arg2)->valid){
+      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->wssr));
+      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->wssr_sf));
+      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->weight_max));
+      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->slope_HV[0].max));
+      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int  (((*arg2)->slope_HV[0].prn)));
+      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->slope_HV[1].max));
+      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int  (((*arg2)->slope_HV[1].prn)));
+    }
+  }
+  {
+    if((*arg3)->valid){
+      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int  (((*arg3)->excluded)));
+      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(
+          (new System_XYZ<double, WGS84>((*arg3)->user_position.xyz)),
+          SWIGTYPE_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN))
+      
+      
+      
+      ;
+      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(
+          (new System_LLH<double, WGS84>((*arg3)->user_position.llh)),
+          SWIGTYPE_System_LLHT_double_WGS84_t, SWIG_POINTER_OWN))
+      
+      
+      
+      ;
+    }
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN void
+free_GPS_User_PVT_Sl_double_Sg_(void *self) {
+    GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *)self;
+    delete arg1;
+}
+
+/*
+  Document-class: GPS_PVT::GPS::Measurement
+
+  Proxy of C++ GPS_PVT::GPS::Measurement class
+
+
+*/
+static swig_class SwigClassMeasurement;
+
+/*
+  Document-method: GPS_PVT::GPS.L1_PSEUDORANGE
+
+  call-seq:
+    L1_PSEUDORANGE -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L1_DOPPLER
+
+  call-seq:
+    L1_DOPPLER -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L1_CARRIER_PHASE
+
+  call-seq:
+    L1_CARRIER_PHASE -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L1_RANGE_RATE
+
+  call-seq:
+    L1_RANGE_RATE -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L1_PSEUDORANGE_SIGMA
+
+  call-seq:
+    L1_PSEUDORANGE_SIGMA -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L1_DOPPLER_SIGMA
+
+  call-seq:
+    L1_DOPPLER_SIGMA -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L1_CARRIER_PHASE_SIGMA
+
+  call-seq:
+    L1_CARRIER_PHASE_SIGMA -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L1_RANGE_RATE_SIGMA
+
+  call-seq:
+    L1_RANGE_RATE_SIGMA -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L1_SIGNAL_STRENGTH_dBHz
+
+  call-seq:
+    L1_SIGNAL_STRENGTH_dBHz -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L1_LOCK_SEC
+
+  call-seq:
+    L1_LOCK_SEC -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L1_FREQUENCY
+
+  call-seq:
+    L1_FREQUENCY -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CM_PSEUDORANGE
+
+  call-seq:
+    L2CM_PSEUDORANGE -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CL_PSEUDORANGE
+
+  call-seq:
+    L2CL_PSEUDORANGE -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CM_PSEUDORANGE_SIGMA
+
+  call-seq:
+    L2CM_PSEUDORANGE_SIGMA -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CL_PSEUDORANGE_SIGMA
+
+  call-seq:
+    L2CL_PSEUDORANGE_SIGMA -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CM_CARRIER_PHASE
 
   call-seq:
-    fde_2nd
+    L2CM_CARRIER_PHASE -> int
 
-An instance method.
+A class method.
 
 */
-SWIGINTERN VALUE
-_wrap_PVT_fde_2nd(int argc, VALUE *argv, VALUE self) {
-  GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
-  GPS_User_PVT< double >::base_t::detection_t **arg2 = (GPS_User_PVT< double >::base_t::detection_t **) 0 ;
-  GPS_User_PVT< double >::base_t::exclusion_t **arg3 = (GPS_User_PVT< double >::base_t::exclusion_t **) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  GPS_User_PVT< double >::base_t::detection_t *temp2 ;
-  GPS_User_PVT< double >::base_t::exclusion_t *temp3 ;
-  VALUE vresult = Qnil;
-  
-  {
-    arg2 = &temp2;
-  }
-  {
-    arg3 = &temp3;
-  }
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_User_PVTT_double_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","fde_2nd", 1, self )); 
-  }
-  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
-  {
-    try {
-      ((GPS_User_PVT< double > const *)arg1)->fde_2nd((GPS_User_PVT< double >::base_t::detection_t const **)arg2,(GPS_User_PVT< double >::base_t::exclusion_t const **)arg3);
-    } catch (const native_exception &e) {
-      e.regenerate();
-      SWIG_fail;
-    } catch (const std::exception& e) {
-      SWIG_exception_fail(SWIG_RuntimeError, e.what());
-    }
-  }
-  vresult = rb_ary_new();
-  {
-    if((*arg2)->valid){
-      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->wssr));
-      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->wssr_sf));
-      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->weight_max));
-      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->slope_HV[0].max));
-      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int  (((*arg2)->slope_HV[0].prn)));
-      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->slope_HV[1].max));
-      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int  (((*arg2)->slope_HV[1].prn)));
-    }
-  }
-  {
-    if((*arg3)->valid){
-      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int  (((*arg3)->excluded)));
-      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(
-          (new System_XYZ<double, WGS84>((*arg3)->user_position.xyz)),
-          SWIGTYPE_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN))
-      
-      
-      
-      ;
-      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(
-          (new System_LLH<double, WGS84>((*arg3)->user_position.llh)),
-          SWIGTYPE_System_LLHT_double_WGS84_t, SWIG_POINTER_OWN))
-      
-      
-      
-      ;
-    }
-  }
-  return vresult;
-fail:
-  return Qnil;
-}
+/*
+  Document-method: GPS_PVT::GPS.L2CL_CARRIER_PHASE
 
+  call-seq:
+    L2CL_CARRIER_PHASE -> int
 
-SWIGINTERN void
-free_GPS_User_PVT_Sl_double_Sg_(void *self) {
-    GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *)self;
-    delete arg1;
-}
+A class method.
 
+*/
 /*
-  Document-class: GPS_PVT::GPS::Measurement
+  Document-method: GPS_PVT::GPS.L2CM_CARRIER_PHASE_SIGMA
 
-  Proxy of C++ GPS_PVT::GPS::Measurement class
+  call-seq:
+    L2CM_CARRIER_PHASE_SIGMA -> int
 
+A class method.
 
 */
-static swig_class SwigClassMeasurement;
+/*
+  Document-method: GPS_PVT::GPS.L2CL_CARRIER_PHASE_SIGMA
+
+  call-seq:
+    L2CL_CARRIER_PHASE_SIGMA -> int
+
+A class method.
 
+*/
 /*
-  Document-method: GPS_PVT::GPS.L1_PSEUDORANGE
+  Document-method: GPS_PVT::GPS.L2CM_DOPPLER
 
   call-seq:
-    L1_PSEUDORANGE -> int
+    L2CM_DOPPLER -> int
 
 A class method.
 
 */
 /*
-  Document-method: GPS_PVT::GPS.L1_DOPPLER
+  Document-method: GPS_PVT::GPS.L2CL_DOPPLER
 
   call-seq:
-    L1_DOPPLER -> int
+    L2CL_DOPPLER -> int
 
 A class method.
 
 */
 /*
-  Document-method: GPS_PVT::GPS.L1_CARRIER_PHASE
+  Document-method: GPS_PVT::GPS.L2CM_DOPPLER_SIGMA
 
   call-seq:
-    L1_CARRIER_PHASE -> int
+    L2CM_DOPPLER_SIGMA -> int
 
 A class method.
 
 */
 /*
-  Document-method: GPS_PVT::GPS.L1_RANGE_RATE
+  Document-method: GPS_PVT::GPS.L2CL_DOPPLER_SIGMA
 
   call-seq:
-    L1_RANGE_RATE -> int
+    L2CL_DOPPLER_SIGMA -> int
 
 A class method.
 
 */
 /*
-  Document-method: GPS_PVT::GPS.L1_PSEUDORANGE_SIGMA
+  Document-method: GPS_PVT::GPS.L2CM_RANGE_RATE
 
   call-seq:
-    L1_PSEUDORANGE_SIGMA -> int
+    L2CM_RANGE_RATE -> int
 
 A class method.
 
 */
 /*
-  Document-method: GPS_PVT::GPS.L1_DOPPLER_SIGMA
+  Document-method: GPS_PVT::GPS.L2CL_RANGE_RATE
 
   call-seq:
-    L1_DOPPLER_SIGMA -> int
+    L2CL_RANGE_RATE -> int
 
 A class method.
 
 */
 /*
-  Document-method: GPS_PVT::GPS.L1_CARRIER_PHASE_SIGMA
+  Document-method: GPS_PVT::GPS.L2CM_RANGE_RATE_SIGMA
 
   call-seq:
-    L1_CARRIER_PHASE_SIGMA -> int
+    L2CM_RANGE_RATE_SIGMA -> int
 
 A class method.
 
 */
 /*
-  Document-method: GPS_PVT::GPS.L1_RANGE_RATE_SIGMA
+  Document-method: GPS_PVT::GPS.L2CL_RANGE_RATE_SIGMA
 
   call-seq:
-    L1_RANGE_RATE_SIGMA -> int
+    L2CL_RANGE_RATE_SIGMA -> int
 
 A class method.
 
 */
 /*
-  Document-method: GPS_PVT::GPS.L1_SIGNAL_STRENGTH_dBHz
+  Document-method: GPS_PVT::GPS.L2CM_SIGNAL_STRENGTH_dBHz
 
   call-seq:
-    L1_SIGNAL_STRENGTH_dBHz -> int
+    L2CM_SIGNAL_STRENGTH_dBHz -> int
 
 A class method.
 
 */
 /*
-  Document-method: GPS_PVT::GPS.L1_LOCK_SEC
+  Document-method: GPS_PVT::GPS.L2CL_SIGNAL_STRENGTH_dBHz
 
   call-seq:
-    L1_LOCK_SEC -> int
+    L2CL_SIGNAL_STRENGTH_dBHz -> int
 
 A class method.
 
 */
 /*
-  Document-method: GPS_PVT::GPS.L1_FREQUENCY
+  Document-method: GPS_PVT::GPS.L2CM_LOCK_SEC
 
   call-seq:
-    L1_FREQUENCY -> int
+    L2CM_LOCK_SEC -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CL_LOCK_SEC
+
+  call-seq:
+    L2CL_LOCK_SEC -> int
 
 A class method.
 
@@ -16141,169 +17010,40 @@ fail:
 }
 
 
-SWIGINTERN VALUE
-#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
-_wrap_Measurement_allocate(VALUE self)
-#else
-_wrap_Measurement_allocate(int argc, VALUE *argv, VALUE self)
-#endif
-{
-  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_GPS_MeasurementT_double_t);
-#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
-  rb_obj_call_init(vresult, argc, argv);
-#endif
-  return vresult;
-}
-
-
-SWIGINTERN VALUE
-_wrap_new_Measurement__SWIG_1(int argc, VALUE *argv, VALUE self) {
-  GPS_Measurement< double > *arg1 = 0 ;
-  GPS_Measurement< double > temp1 ;
-  GPS_Measurement< double > *result = 0 ;
-  
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
-  }
-  {
-    if((!SWIG_IsOK(SWIG_ConvertPtr(argv[0], (void **)&arg1, SWIGTYPE_p_GPS_MeasurementT_double_t, 0)))
-      && (!SWIG_IsOK(swig::asval(argv[0], (arg1 = &temp1))))){
-      SWIG_exception(SWIG_TypeError, "in method 'GPS_Measurement<(double)>', expecting type GPS_Measurement< double >");
-    }
-  }
-  {
-    try {
-      result = (GPS_Measurement< double > *)new GPS_Measurement< double >((GPS_Measurement< double > const &)*arg1);
-      DATA_PTR(self) = result;
-    } catch (const native_exception &e) {
-      e.regenerate();
-      SWIG_fail;
-    } catch (const std::exception& e) {
-      SWIG_exception_fail(SWIG_RuntimeError, e.what());
-    }
-  }
-  return self;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE _wrap_new_Measurement(int nargs, VALUE *args, VALUE self) {
-  int argc;
-  VALUE argv[1];
-  int ii;
-  
-  argc = nargs;
-  if (argc > 1) SWIG_fail;
-  for (ii = 0; (ii < argc); ++ii) {
-    argv[ii] = args[ii];
-  }
-  if (argc == 0) {
-    return _wrap_new_Measurement__SWIG_0(nargs, args, self);
-  }
-  if (argc == 1) {
-    int _v;
-    {
-      _v = SWIG_CheckState(SWIG_ConvertPtr(argv[0], (void **)0, SWIGTYPE_p_GPS_MeasurementT_double_t, 0))
-      || swig::check<GPS_Measurement<double> >(argv[0]);
-    }
-    if (_v) {
-      return _wrap_new_Measurement__SWIG_1(nargs, args, self);
-    }
-  }
-  
-fail:
-  Ruby_Format_OverloadedError( argc, 1, "Measurement.new", 
-    "    Measurement.new()\n"
-    "    Measurement.new(GPS_Measurement< double > const &other)\n");
-  
-  return Qnil;
-}
-
-
-SWIGINTERN void
-free_GPS_Measurement_Sl_double_Sg_(void *self) {
-    GPS_Measurement< double > *arg1 = (GPS_Measurement< double > *)self;
-    delete arg1;
-}
-
-/*
-  Document-class: GPS_PVT::GPS::SolverOptionsCommon
-
-  Proxy of C++ GPS_PVT::GPS::SolverOptionsCommon class
-
-
-*/
-static swig_class SwigClassSolverOptionsCommon;
-
-SWIGINTERN void
-free_GPS_SolverOptions_Common_Sl_double_Sg_(void *self) {
-    GPS_SolverOptions_Common< double > *arg1 = (GPS_SolverOptions_Common< double > *)self;
-    delete arg1;
-}
-
-/*
-  Document-method: GPS_PVT::GPS::SolverOptionsCommon.cast_general
-
-  call-seq:
-    cast_general -> GPS_Solver_GeneralOptions< double > *
-    cast_general -> GPS_Solver_GeneralOptions< double > const
-
-An instance method.
-
-*/
-SWIGINTERN VALUE
-_wrap_SolverOptionsCommon_cast_general__SWIG_0(int argc, VALUE *argv, VALUE self) {
-  GPS_SolverOptions_Common< double > *arg1 = (GPS_SolverOptions_Common< double > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  GPS_Solver_GeneralOptions< double > *result = 0 ;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SolverOptions_Common< double > *","cast_general", 1, self )); 
-  }
-  arg1 = reinterpret_cast< GPS_SolverOptions_Common< double > * >(argp1);
-  {
-    try {
-      result = (GPS_Solver_GeneralOptions< double > *)(arg1)->cast_general();
-    } catch (const native_exception &e) {
-      e.regenerate();
-      SWIG_fail;
-    } catch (const std::exception& e) {
-      SWIG_exception_fail(SWIG_RuntimeError, e.what());
-    }
-  }
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GPS_Solver_GeneralOptionsT_double_t, 0 |  0 );
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_Measurement_allocate(VALUE self)
+#else
+_wrap_Measurement_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_GPS_MeasurementT_double_t);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
   return vresult;
-fail:
-  return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_SolverOptionsCommon_cast_general__SWIG_1(int argc, VALUE *argv, VALUE self) {
-  GPS_SolverOptions_Common< double > *arg1 = (GPS_SolverOptions_Common< double > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  GPS_Solver_GeneralOptions< double > *result = 0 ;
-  VALUE vresult = Qnil;
+_wrap_new_Measurement__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  GPS_Measurement< double > *arg1 = 0 ;
+  GPS_Measurement< double > temp1 ;
+  GPS_Measurement< double > *result = 0 ;
   
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SolverOptions_Common< double > const *","cast_general", 1, self )); 
+  {
+    if((!SWIG_IsOK(SWIG_ConvertPtr(argv[0], (void **)&arg1, SWIGTYPE_p_GPS_MeasurementT_double_t, 0)))
+      && (!SWIG_IsOK(swig::asval(argv[0], (arg1 = &temp1))))){
+      SWIG_exception(SWIG_TypeError, "in method 'GPS_Measurement<(double)>', expecting type GPS_Measurement< double >");
+    }
   }
-  arg1 = reinterpret_cast< GPS_SolverOptions_Common< double > * >(argp1);
   {
     try {
-      result = (GPS_Solver_GeneralOptions< double > *)((GPS_SolverOptions_Common< double > const *)arg1)->cast_general();
+      result = (GPS_Measurement< double > *)new GPS_Measurement< double >((GPS_Measurement< double > const &)*arg1);
+      DATA_PTR(self) = result;
     } catch (const native_exception &e) {
       e.regenerate();
       SWIG_fail;
@@ -16311,52 +17051,66 @@ _wrap_SolverOptionsCommon_cast_general__SWIG_1(int argc, VALUE *argv, VALUE self
       SWIG_exception_fail(SWIG_RuntimeError, e.what());
     }
   }
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GPS_Solver_GeneralOptionsT_double_t, 0 |  0 );
-  return vresult;
+  return self;
 fail:
   return Qnil;
 }
 
 
-SWIGINTERN VALUE _wrap_SolverOptionsCommon_cast_general(int nargs, VALUE *args, VALUE self) {
+SWIGINTERN VALUE _wrap_new_Measurement(int nargs, VALUE *args, VALUE self) {
   int argc;
-  VALUE argv[2];
+  VALUE argv[1];
   int ii;
   
-  argc = nargs + 1;
-  argv[0] = self;
-  if (argc > 2) SWIG_fail;
-  for (ii = 1; (ii < argc); ++ii) {
-    argv[ii] = args[ii-1];
+  argc = nargs;
+  if (argc > 1) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
   }
-  if (argc == 1) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_SolverOptionsCommon_cast_general__SWIG_0(nargs, args, self);
-    }
+  if (argc == 0) {
+    return _wrap_new_Measurement__SWIG_0(nargs, args, self);
   }
   if (argc == 1) {
     int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, 0);
-    _v = SWIG_CheckState(res);
+    {
+      _v = SWIG_CheckState(SWIG_ConvertPtr(argv[0], (void **)0, SWIGTYPE_p_GPS_MeasurementT_double_t, 0))
+      || swig::check<GPS_Measurement<double> >(argv[0]);
+    }
     if (_v) {
-      return _wrap_SolverOptionsCommon_cast_general__SWIG_1(nargs, args, self);
+      return _wrap_new_Measurement__SWIG_1(nargs, args, self);
     }
   }
   
 fail:
-  Ruby_Format_OverloadedError( argc, 2, "SolverOptionsCommon.cast_general", 
-    "    GPS_Solver_GeneralOptions< double > SolverOptionsCommon.cast_general()\n"
-    "    GPS_Solver_GeneralOptions< double > const * SolverOptionsCommon.cast_general()\n");
+  Ruby_Format_OverloadedError( argc, 1, "Measurement.new", 
+    "    Measurement.new()\n"
+    "    Measurement.new(GPS_Measurement< double > const &other)\n");
   
   return Qnil;
 }
 
 
+SWIGINTERN void
+free_GPS_Measurement_Sl_double_Sg_(void *self) {
+    GPS_Measurement< double > *arg1 = (GPS_Measurement< double > *)self;
+    delete arg1;
+}
+
+/*
+  Document-class: GPS_PVT::GPS::SolverOptionsCommon
+
+  Proxy of C++ GPS_PVT::GPS::SolverOptionsCommon class
+
+
+*/
+static swig_class SwigClassSolverOptionsCommon;
+
+SWIGINTERN void
+free_GPS_SolverOptions_Common_Sl_double_Sg_(void *self) {
+    GPS_SolverOptions_Common< double > *arg1 = (GPS_SolverOptions_Common< double > *)self;
+    delete arg1;
+}
+
 /*
   Document-method: GPS_PVT::GPS::SolverOptionsCommon.elevation_mask=
 
@@ -16701,6 +17455,100 @@ fail:
 }
 
 
+/*
+  Document-method: GPS_PVT::GPS::SolverOptions.exclude_L2C?
+
+  call-seq:
+    exclude_L2C? -> bool
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_SolverOptions_exclude_L2Cq___(int argc, VALUE *argv, VALUE self) {
+  GPS_SolverOptions< double > *arg1 = (GPS_SolverOptions< double > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SolverOptionsT_double_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SolverOptions< double > *","get_exclude_L2C", 1, self )); 
+  }
+  arg1 = reinterpret_cast< GPS_SolverOptions< double > * >(argp1);
+  {
+    try {
+      result = (bool)(arg1)->get_exclude_L2C();
+    } catch (const native_exception &e) {
+      e.regenerate();
+      SWIG_fail;
+    } catch (const std::exception& e) {
+      SWIG_exception_fail(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+/*
+  Document-method: GPS_PVT::GPS::SolverOptions.exclude_L2C=
+
+  call-seq:
+    exclude_L2C=(bool const & b) -> bool
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_SolverOptions_exclude_L2Ce___(int argc, VALUE *argv, VALUE self) {
+  GPS_SolverOptions< double > *arg1 = (GPS_SolverOptions< double > *) 0 ;
+  bool *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool temp2 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SolverOptionsT_double_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SolverOptions< double > *","set_exclude_L2C", 1, self )); 
+  }
+  arg1 = reinterpret_cast< GPS_SolverOptions< double > * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","set_exclude_L2C", 2, argv[0] ));
+  } 
+  temp2 = static_cast< bool >(val2);
+  arg2 = &temp2;
+  {
+    try {
+      result = (bool)(arg1)->set_exclude_L2C((bool const &)*arg2);
+    } catch (const native_exception &e) {
+      e.regenerate();
+      SWIG_fail;
+    } catch (const std::exception& e) {
+      SWIG_exception_fail(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
 _wrap_SolverOptions_allocate(VALUE self)
@@ -17450,21 +18298,116 @@ SWIGINTERN VALUE _wrap_new_Ephemeris_SBAS(int nargs, VALUE *args, VALUE self) {
   if (argc == 0) {
     return _wrap_new_Ephemeris_SBAS__SWIG_0(nargs, args, self);
   }
-  if (argc == 1) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBAS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris, SWIG_POINTER_NO_NULL);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_new_Ephemeris_SBAS__SWIG_1(nargs, args, self);
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBAS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris, SWIG_POINTER_NO_NULL);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_Ephemeris_SBAS__SWIG_1(nargs, args, self);
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 1, "Ephemeris_SBAS.new", 
+    "    Ephemeris_SBAS.new()\n"
+    "    Ephemeris_SBAS.new(SBAS_SpaceNode< double >::SatelliteProperties::Ephemeris const &eph)\n");
+  
+  return Qnil;
+}
+
+
+/*
+  Document-method: GPS_PVT::GPS::Ephemeris_SBAS.valid?
+
+  call-seq:
+    valid?(Time t) -> bool
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_Ephemeris_SBAS_validq___(int argc, VALUE *argv, VALUE self) {
+  SBAS_Ephemeris< double > *arg1 = (SBAS_Ephemeris< double > *) 0 ;
+  GPS_Time< double > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SBAS_EphemerisT_double_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_Ephemeris< double > const *","is_valid", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SBAS_Ephemeris< double > * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPS_TimeT_double_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_Time< double > const &","is_valid", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","is_valid", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
+  {
+    try {
+      result = (bool)((SBAS_Ephemeris< double > const *)arg1)->is_valid((GPS_Time< double > const &)*arg2);
+    } catch (const native_exception &e) {
+      e.regenerate();
+      SWIG_fail;
+    } catch (const std::exception& e) {
+      SWIG_exception_fail(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+/*
+  Document-method: GPS_PVT::GPS::Ephemeris_SBAS.t_applicable
+
+  call-seq:
+    t_applicable -> Time
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_Ephemeris_SBAS_t_applicable(int argc, VALUE *argv, VALUE self) {
+  SBAS_Ephemeris< double > *arg1 = (SBAS_Ephemeris< double > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  GPS_Time< double > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SBAS_EphemerisT_double_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_Ephemeris< double > const *","t_applicable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SBAS_Ephemeris< double > * >(argp1);
+  {
+    try {
+      result = ((SBAS_Ephemeris< double > const *)arg1)->t_applicable();
+    } catch (const native_exception &e) {
+      e.regenerate();
+      SWIG_fail;
+    } catch (const std::exception& e) {
+      SWIG_exception_fail(SWIG_RuntimeError, e.what());
     }
   }
-  
+  vresult = SWIG_NewPointerObj((new GPS_Time< double >(static_cast< const GPS_Time< double >& >(result))), SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_OWN |  0 );
+  return vresult;
 fail:
-  Ruby_Format_OverloadedError( argc, 1, "Ephemeris_SBAS.new", 
-    "    Ephemeris_SBAS.new()\n"
-    "    Ephemeris_SBAS.new(SBAS_SpaceNode< double >::SatelliteProperties::Ephemeris const &eph)\n");
-  
   return Qnil;
 }
 
@@ -18879,6 +19822,153 @@ fail:
 }
 
 
+/*
+  Document-method: GPS_PVT::GPS::Ephemeris_SBAS.dump
+
+  call-seq:
+    dump(unsigned int const & preamble_idx=0)
+    dump
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_Ephemeris_SBAS_dump__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  SBAS_Ephemeris< double > *arg1 = (SBAS_Ephemeris< double > *) 0 ;
+  unsigned int *arg2 ;
+  unsigned int *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int temp2[8] = {
+    0
+  } ;
+  unsigned int temp3 ;
+  unsigned int val3 ;
+  int ecode3 = 0 ;
+  VALUE vresult = Qnil;
+  
+  arg2 = temp2;
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SBAS_EphemerisT_double_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_Ephemeris< double > *","dump", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SBAS_Ephemeris< double > * >(argp1);
+  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[0], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","dump", 3, argv[0] ));
+  } 
+  temp3 = static_cast< unsigned int >(val3);
+  arg3 = &temp3;
+  {
+    try {
+      SBAS_Ephemeris_Sl_double_Sg__dump__SWIG_0(arg1,arg2,(unsigned int const &)*arg3);
+    } catch (const native_exception &e) {
+      e.regenerate();
+      SWIG_fail;
+    } catch (const std::exception& e) {
+      SWIG_exception_fail(SWIG_RuntimeError, e.what());
+    }
+  }
+  {
+    for(int i(0); i < 8; ++i){
+      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int  ((arg2)[i]));
+    }
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Ephemeris_SBAS_dump__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  SBAS_Ephemeris< double > *arg1 = (SBAS_Ephemeris< double > *) 0 ;
+  unsigned int *arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int temp2[8] = {
+    0
+  } ;
+  VALUE vresult = Qnil;
+  
+  arg2 = temp2;
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SBAS_EphemerisT_double_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_Ephemeris< double > *","dump", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SBAS_Ephemeris< double > * >(argp1);
+  {
+    try {
+      SBAS_Ephemeris_Sl_double_Sg__dump__SWIG_0(arg1,arg2);
+    } catch (const native_exception &e) {
+      e.regenerate();
+      SWIG_fail;
+    } catch (const std::exception& e) {
+      SWIG_exception_fail(SWIG_RuntimeError, e.what());
+    }
+  }
+  {
+    for(int i(0); i < 8; ++i){
+      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int  ((arg2)[i]));
+    }
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_Ephemeris_SBAS_dump(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBAS_EphemerisT_double_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Ephemeris_SBAS_dump__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBAS_EphemerisT_double_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Ephemeris_SBAS_dump__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "dump", 
+    "    void dump(unsigned int buf_brdc[8], unsigned int const &preamble_idx)\n"
+    "    void dump(unsigned int buf_brdc[8])\n");
+  
+  return Qnil;
+}
+
+
 /*
   Document-method: GPS_PVT::GPS::Ephemeris_SBAS.constellation
 
@@ -21479,6 +22569,59 @@ fail:
 }
 
 
+/*
+  Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.valid?
+
+  call-seq:
+    valid?(Time t) -> bool
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_Ephemeris_GLONASS_validq___(int argc, VALUE *argv, VALUE self) {
+  GLONASS_Ephemeris< double > *arg1 = (GLONASS_Ephemeris< double > *) 0 ;
+  GPS_Time< double > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLONASS_EphemerisT_double_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GLONASS_Ephemeris< double > const *","is_valid", 1, self )); 
+  }
+  arg1 = reinterpret_cast< GLONASS_Ephemeris< double > * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPS_TimeT_double_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_Time< double > const &","is_valid", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","is_valid", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
+  {
+    try {
+      result = (bool)((GLONASS_Ephemeris< double > const *)arg1)->is_valid((GPS_Time< double > const &)*arg2);
+    } catch (const native_exception &e) {
+      e.regenerate();
+      SWIG_fail;
+    } catch (const std::exception& e) {
+      SWIG_exception_fail(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 /*
   Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.new
 
@@ -24520,6 +25663,108 @@ fail:
 }
 
 
+/*
+  Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.dump
+
+  call-seq:
+    dump(Time t)
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_Ephemeris_GLONASS_dump(int argc, VALUE *argv, VALUE self) {
+  GLONASS_Ephemeris< double > *arg1 = (GLONASS_Ephemeris< double > *) 0 ;
+  unsigned int *arg2 ;
+  unsigned int *arg3 ;
+  unsigned int *arg4 ;
+  unsigned int *arg5 ;
+  unsigned int *arg6 ;
+  GPS_Time< double > *arg7 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int temp2[3] = {
+    0
+  } ;
+  unsigned int temp3[3] = {
+    0
+  } ;
+  unsigned int temp4[3] = {
+    0
+  } ;
+  unsigned int temp5[3] = {
+    0
+  } ;
+  unsigned int temp6[3] = {
+    0
+  } ;
+  void *argp7 ;
+  int res7 = 0 ;
+  VALUE vresult = Qnil;
+  
+  arg2 = temp2;
+  arg3 = temp3;
+  arg4 = temp4;
+  arg5 = temp5;
+  arg6 = temp6;
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLONASS_EphemerisT_double_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GLONASS_Ephemeris< double > *","dump", 1, self )); 
+  }
+  arg1 = reinterpret_cast< GLONASS_Ephemeris< double > * >(argp1);
+  res7 = SWIG_ConvertPtr(argv[0], &argp7, SWIGTYPE_p_GPS_TimeT_double_t,  0 );
+  if (!SWIG_IsOK(res7)) {
+    SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "GPS_Time< double > const &","dump", 7, argv[0] )); 
+  }
+  if (!argp7) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","dump", 7, argv[0])); 
+  }
+  arg7 = reinterpret_cast< GPS_Time< double > * >(argp7);
+  {
+    try {
+      GLONASS_Ephemeris_Sl_double_Sg__dump(arg1,arg2,arg3,arg4,arg5,arg6,(GPS_Time< double > const &)*arg7);
+    } catch (const native_exception &e) {
+      e.regenerate();
+      SWIG_fail;
+    } catch (const std::exception& e) {
+      SWIG_exception_fail(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = rb_ary_new();
+  {
+    for(int i(0); i < 3; ++i){
+      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int  ((arg2)[i]));
+    }
+  }
+  {
+    for(int i(0); i < 3; ++i){
+      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int  ((arg3)[i]));
+    }
+  }
+  {
+    for(int i(0); i < 3; ++i){
+      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int  ((arg4)[i]));
+    }
+  }
+  {
+    for(int i(0); i < 3; ++i){
+      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int  ((arg5)[i]));
+    }
+  }
+  {
+    for(int i(0); i < 3; ++i){
+      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int  ((arg6)[i]));
+    }
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 /*
   Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.constellation
 
@@ -26221,7 +27466,6 @@ static swig_type_info _swigt__p_GPS_MeasurementT_double_t = {"_p_GPS_Measurement
 static swig_type_info _swigt__p_GPS_SolverOptionsT_double_t = {"_p_GPS_SolverOptionsT_double_t", "GPS_SolverOptions< double > *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_GPS_SolverOptions_CommonT_double_t = {"_p_GPS_SolverOptions_CommonT_double_t", "GPS_SolverOptions_Common< double > *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_GPS_SolverT_double_t = {"_p_GPS_SolverT_double_t", "GPS_Solver< double > *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_GPS_Solver_GeneralOptionsT_double_t = {"_p_GPS_Solver_GeneralOptionsT_double_t", "GPS_Solver_GeneralOptions< double > *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_GPS_SpaceNodeT_double_t = {"_p_GPS_SpaceNodeT_double_t", "GPS_SpaceNode< double >::self_t *|GPS_SpaceNode< double > *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters = {"_p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters", "GPS_SpaceNode< double >::Ionospheric_UTC_Parameters *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_GPS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris = {"_p_GPS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris", "GPS_SpaceNode< double >::SatelliteProperties::Ephemeris *", 0, 0, (void*)0, 0};
@@ -26272,6 +27516,7 @@ static swig_type_info _swigt__p_u16_t = {"_p_u16_t", "u16_t *", 0, 0, (void*)0,
 static swig_type_info _swigt__p_u32_t = {"_p_u32_t", "u32_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_u8_t = {"_p_u8_t", "u8_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_uint_t = {"_p_uint_t", "uint_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_xyz_t = {"_p_xyz_t", "xyz_t *", 0, 0, (void*)0, 0};
 
 static swig_type_info *swig_type_initial[] = {
@@ -26290,7 +27535,6 @@ static swig_type_info *swig_type_initial[] = {
   &_swigt__p_GPS_SolverOptionsT_double_t,
   &_swigt__p_GPS_SolverOptions_CommonT_double_t,
   &_swigt__p_GPS_SolverT_double_t,
-  &_swigt__p_GPS_Solver_GeneralOptionsT_double_t,
   &_swigt__p_GPS_SpaceNodeT_double_t,
   &_swigt__p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters,
   &_swigt__p_GPS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris,
@@ -26341,6 +27585,7 @@ static swig_type_info *swig_type_initial[] = {
   &_swigt__p_u32_t,
   &_swigt__p_u8_t,
   &_swigt__p_uint_t,
+  &_swigt__p_unsigned_int,
   &_swigt__p_xyz_t,
 };
 
@@ -26359,7 +27604,6 @@ static swig_cast_info _swigc__p_GPS_MeasurementT_double_t[] = {  {&_swigt__p_GPS
 static swig_cast_info _swigc__p_GPS_SolverOptionsT_double_t[] = {  {&_swigt__p_GPS_SolverOptionsT_double_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_GPS_SolverOptions_CommonT_double_t[] = {  {&_swigt__p_GPS_SolverOptions_CommonT_double_t, 0, 0, 0},  {&_swigt__p_GPS_SolverOptionsT_double_t, _p_GPS_SolverOptionsT_double_tTo_p_GPS_SolverOptions_CommonT_double_t, 0, 0},  {&_swigt__p_SBAS_SolverOptionsT_double_t, _p_SBAS_SolverOptionsT_double_tTo_p_GPS_SolverOptions_CommonT_double_t, 0, 0},  {&_swigt__p_GLONASS_SolverOptionsT_double_t, _p_GLONASS_SolverOptionsT_double_tTo_p_GPS_SolverOptions_CommonT_double_t, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_GPS_SolverT_double_t[] = {  {&_swigt__p_GPS_SolverT_double_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_GPS_Solver_GeneralOptionsT_double_t[] = {  {&_swigt__p_GPS_Solver_GeneralOptionsT_double_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_GPS_SpaceNodeT_double_t[] = {  {&_swigt__p_GPS_SpaceNodeT_double_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters[] = {  {&_swigt__p_GPS_Ionospheric_UTC_ParametersT_double_t, _p_GPS_Ionospheric_UTC_ParametersT_double_tTo_p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters, 0, 0},  {&_swigt__p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_GPS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris[] = {  {&_swigt__p_GPS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris, 0, 0, 0},  {&_swigt__p_GPS_EphemerisT_double_t, _p_GPS_EphemerisT_double_tTo_p_GPS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris, 0, 0},{0, 0, 0, 0}};
@@ -26410,6 +27654,7 @@ static swig_cast_info _swigc__p_u16_t[] = {  {&_swigt__p_u16_t, 0, 0, 0},{0, 0,
 static swig_cast_info _swigc__p_u32_t[] = {  {&_swigt__p_u32_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_u8_t[] = {  {&_swigt__p_u8_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_uint_t[] = {  {&_swigt__p_uint_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_xyz_t[] = {  {&_swigt__p_xyz_t, 0, 0, 0},{0, 0, 0, 0}};
 
 static swig_cast_info *swig_cast_initial[] = {
@@ -26428,7 +27673,6 @@ static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_GPS_SolverOptionsT_double_t,
   _swigc__p_GPS_SolverOptions_CommonT_double_t,
   _swigc__p_GPS_SolverT_double_t,
-  _swigc__p_GPS_Solver_GeneralOptionsT_double_t,
   _swigc__p_GPS_SpaceNodeT_double_t,
   _swigc__p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters,
   _swigc__p_GPS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris,
@@ -26479,6 +27723,7 @@ static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_u32_t,
   _swigc__p_u8_t,
   _swigc__p_uint_t,
+  _swigc__p_unsigned_int,
   _swigc__p_xyz_t,
 };
 
@@ -26864,6 +28109,7 @@ SWIGEXPORT void Init_GPS(void) {
   rb_define_method(SwigClassIonospheric_UTC_Parameters.klass, "delta_t_LSF=", VALUEFUNC(_wrap_Ionospheric_UTC_Parameters_delta_t_LSFe___), -1);
   rb_define_method(SwigClassIonospheric_UTC_Parameters.klass, "delta_t_LSF", VALUEFUNC(_wrap_Ionospheric_UTC_Parameters_delta_t_LSF), -1);
   rb_define_singleton_method(SwigClassIonospheric_UTC_Parameters.klass, "parse", VALUEFUNC(_wrap_Ionospheric_UTC_Parameters_parse), -1);
+  rb_define_method(SwigClassIonospheric_UTC_Parameters.klass, "dump", VALUEFUNC(_wrap_Ionospheric_UTC_Parameters_dump), -1);
   SwigClassIonospheric_UTC_Parameters.mark = 0;
   SwigClassIonospheric_UTC_Parameters.destroy = (void (*)(void *)) free_GPS_Ionospheric_UTC_Parameters_Sl_double_Sg_;
   SwigClassIonospheric_UTC_Parameters.trackObjects = 0;
@@ -26876,6 +28122,9 @@ SWIGEXPORT void Init_GPS(void) {
   rb_define_method(SwigClassEphemeris.klass, "iode_subframe3", VALUEFUNC(_wrap_Ephemeris_iode_subframe3_get), -1);
   rb_define_method(SwigClassEphemeris.klass, "invalidate", VALUEFUNC(_wrap_Ephemeris_invalidate), -1);
   rb_define_method(SwigClassEphemeris.klass, "consistent?", VALUEFUNC(_wrap_Ephemeris_consistentq___), -1);
+  rb_define_method(SwigClassEphemeris.klass, "valid?", VALUEFUNC(_wrap_Ephemeris_validq___), -1);
+  rb_define_method(SwigClassEphemeris.klass, "t_clock", VALUEFUNC(_wrap_Ephemeris_t_clock), -1);
+  rb_define_method(SwigClassEphemeris.klass, "t_ephemeris", VALUEFUNC(_wrap_Ephemeris_t_ephemeris), -1);
   rb_define_method(SwigClassEphemeris.klass, "svid=", VALUEFUNC(_wrap_Ephemeris_svide___), -1);
   rb_define_method(SwigClassEphemeris.klass, "svid", VALUEFUNC(_wrap_Ephemeris_svid), -1);
   rb_define_method(SwigClassEphemeris.klass, "WN=", VALUEFUNC(_wrap_Ephemeris_WNe___), -1);
@@ -26933,6 +28182,9 @@ SWIGEXPORT void Init_GPS(void) {
   rb_define_method(SwigClassEphemeris.klass, "dot_i0=", VALUEFUNC(_wrap_Ephemeris_dot_i0e___), -1);
   rb_define_method(SwigClassEphemeris.klass, "dot_i0", VALUEFUNC(_wrap_Ephemeris_dot_i0), -1);
   rb_define_method(SwigClassEphemeris.klass, "parse", VALUEFUNC(_wrap_Ephemeris_parse), -1);
+  rb_define_method(SwigClassEphemeris.klass, "dump", VALUEFUNC(_wrap_Ephemeris_dump), -1);
+  rb_define_method(SwigClassEphemeris.klass, "parse_almanac", VALUEFUNC(_wrap_Ephemeris_parse_almanac), -1);
+  rb_define_method(SwigClassEphemeris.klass, "dump_almanac", VALUEFUNC(_wrap_Ephemeris_dump_almanac), -1);
   rb_define_method(SwigClassEphemeris.klass, "constellation", VALUEFUNC(_wrap_Ephemeris_constellation), -1);
   SwigClassEphemeris.mark = 0;
   SwigClassEphemeris.destroy = (void (*)(void *)) free_GPS_Ephemeris_Sl_double_Sg_;
@@ -27001,6 +28253,26 @@ SWIGEXPORT void Init_GPS(void) {
   rb_define_const(SwigClassMeasurement.klass, "L1_SIGNAL_STRENGTH_dBHz", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L1_SIGNAL_STRENGTH_dBHz)));
   rb_define_const(SwigClassMeasurement.klass, "L1_LOCK_SEC", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L1_LOCK_SEC)));
   rb_define_const(SwigClassMeasurement.klass, "L1_FREQUENCY", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L1_FREQUENCY)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CM_PSEUDORANGE", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CM_PSEUDORANGE)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CL_PSEUDORANGE", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CL_PSEUDORANGE)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CM_PSEUDORANGE_SIGMA", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CM_PSEUDORANGE_SIGMA)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CL_PSEUDORANGE_SIGMA", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CL_PSEUDORANGE_SIGMA)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CM_CARRIER_PHASE", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CM_CARRIER_PHASE)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CL_CARRIER_PHASE", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CL_CARRIER_PHASE)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CM_CARRIER_PHASE_SIGMA", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CM_CARRIER_PHASE_SIGMA)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CL_CARRIER_PHASE_SIGMA", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CL_CARRIER_PHASE_SIGMA)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CM_DOPPLER", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CM_DOPPLER)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CL_DOPPLER", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CL_DOPPLER)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CM_DOPPLER_SIGMA", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CM_DOPPLER_SIGMA)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CL_DOPPLER_SIGMA", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CL_DOPPLER_SIGMA)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CM_RANGE_RATE", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CM_RANGE_RATE)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CL_RANGE_RATE", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CL_RANGE_RATE)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CM_RANGE_RATE_SIGMA", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CM_RANGE_RATE_SIGMA)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CL_RANGE_RATE_SIGMA", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CL_RANGE_RATE_SIGMA)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CM_SIGNAL_STRENGTH_dBHz", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CM_SIGNAL_STRENGTH_dBHz)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CL_SIGNAL_STRENGTH_dBHz", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CL_SIGNAL_STRENGTH_dBHz)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CM_LOCK_SEC", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CM_LOCK_SEC)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CL_LOCK_SEC", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CL_LOCK_SEC)));
   rb_define_const(SwigClassMeasurement.klass, "ITEMS_PREDEFINED", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::ITEMS_PREDEFINED)));
   rb_define_method(SwigClassMeasurement.klass, "add", VALUEFUNC(_wrap_Measurement_add), -1);
   rb_define_method(SwigClassMeasurement.klass, "each", VALUEFUNC(_wrap_Measurement_each), -1);
@@ -27012,7 +28284,6 @@ SWIGEXPORT void Init_GPS(void) {
   SwigClassSolverOptionsCommon.klass = rb_define_class_under(mGPS, "SolverOptionsCommon", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, (void *) &SwigClassSolverOptionsCommon);
   rb_undef_alloc_func(SwigClassSolverOptionsCommon.klass);
-  rb_define_method(SwigClassSolverOptionsCommon.klass, "cast_general", VALUEFUNC(_wrap_SolverOptionsCommon_cast_general), -1);
   rb_define_method(SwigClassSolverOptionsCommon.klass, "elevation_mask=", VALUEFUNC(_wrap_SolverOptionsCommon_elevation_maske___), -1);
   rb_define_method(SwigClassSolverOptionsCommon.klass, "elevation_mask", VALUEFUNC(_wrap_SolverOptionsCommon_elevation_mask), -1);
   rb_define_method(SwigClassSolverOptionsCommon.klass, "residual_mask=", VALUEFUNC(_wrap_SolverOptionsCommon_residual_maske___), -1);
@@ -27028,6 +28299,8 @@ SWIGEXPORT void Init_GPS(void) {
   rb_define_method(SwigClassSolverOptions.klass, "exclude", VALUEFUNC(_wrap_SolverOptions_exclude), -1);
   rb_define_method(SwigClassSolverOptions.klass, "include", VALUEFUNC(_wrap_SolverOptions_include), -1);
   rb_define_method(SwigClassSolverOptions.klass, "excluded", VALUEFUNC(_wrap_SolverOptions_excluded), -1);
+  rb_define_method(SwigClassSolverOptions.klass, "exclude_L2C?", VALUEFUNC(_wrap_SolverOptions_exclude_L2Cq___), -1);
+  rb_define_method(SwigClassSolverOptions.klass, "exclude_L2C=", VALUEFUNC(_wrap_SolverOptions_exclude_L2Ce___), -1);
   SwigClassSolverOptions.mark = 0;
   SwigClassSolverOptions.destroy = (void (*)(void *)) free_GPS_SolverOptions_Sl_double_Sg_;
   SwigClassSolverOptions.trackObjects = 0;
@@ -27056,6 +28329,8 @@ SWIGEXPORT void Init_GPS(void) {
   SWIG_TypeClientData(SWIGTYPE_p_SBAS_EphemerisT_double_t, (void *) &SwigClassEphemeris_SBAS);
   rb_define_alloc_func(SwigClassEphemeris_SBAS.klass, _wrap_Ephemeris_SBAS_allocate);
   rb_define_method(SwigClassEphemeris_SBAS.klass, "initialize", VALUEFUNC(_wrap_new_Ephemeris_SBAS), -1);
+  rb_define_method(SwigClassEphemeris_SBAS.klass, "valid?", VALUEFUNC(_wrap_Ephemeris_SBAS_validq___), -1);
+  rb_define_method(SwigClassEphemeris_SBAS.klass, "t_applicable", VALUEFUNC(_wrap_Ephemeris_SBAS_t_applicable), -1);
   rb_define_method(SwigClassEphemeris_SBAS.klass, "svid=", VALUEFUNC(_wrap_Ephemeris_SBAS_svide___), -1);
   rb_define_method(SwigClassEphemeris_SBAS.klass, "svid", VALUEFUNC(_wrap_Ephemeris_SBAS_svid), -1);
   rb_define_method(SwigClassEphemeris_SBAS.klass, "WN=", VALUEFUNC(_wrap_Ephemeris_SBAS_WNe___), -1);
@@ -27086,6 +28361,7 @@ SWIGEXPORT void Init_GPS(void) {
   rb_define_method(SwigClassEphemeris_SBAS.klass, "a_Gf0", VALUEFUNC(_wrap_Ephemeris_SBAS_a_Gf0), -1);
   rb_define_method(SwigClassEphemeris_SBAS.klass, "a_Gf1=", VALUEFUNC(_wrap_Ephemeris_SBAS_a_Gf1e___), -1);
   rb_define_method(SwigClassEphemeris_SBAS.klass, "a_Gf1", VALUEFUNC(_wrap_Ephemeris_SBAS_a_Gf1), -1);
+  rb_define_method(SwigClassEphemeris_SBAS.klass, "dump", VALUEFUNC(_wrap_Ephemeris_SBAS_dump), -1);
   rb_define_method(SwigClassEphemeris_SBAS.klass, "constellation", VALUEFUNC(_wrap_Ephemeris_SBAS_constellation), -1);
   SwigClassEphemeris_SBAS.mark = 0;
   SwigClassEphemeris_SBAS.destroy = (void (*)(void *)) free_SBAS_Ephemeris_Sl_double_Sg_;
@@ -27173,6 +28449,7 @@ SWIGEXPORT void Init_GPS(void) {
   rb_define_method(SwigClassEphemeris_GLONASS.klass, "raw", VALUEFUNC(_wrap_Ephemeris_GLONASS_raw_get), -1);
   rb_define_method(SwigClassEphemeris_GLONASS.klass, "invalidate", VALUEFUNC(_wrap_Ephemeris_GLONASS_invalidate), -1);
   rb_define_method(SwigClassEphemeris_GLONASS.klass, "consistent?", VALUEFUNC(_wrap_Ephemeris_GLONASS_consistentq___), -1);
+  rb_define_method(SwigClassEphemeris_GLONASS.klass, "valid?", VALUEFUNC(_wrap_Ephemeris_GLONASS_validq___), -1);
   rb_define_method(SwigClassEphemeris_GLONASS.klass, "svid=", VALUEFUNC(_wrap_Ephemeris_GLONASS_svide___), -1);
   rb_define_method(SwigClassEphemeris_GLONASS.klass, "svid", VALUEFUNC(_wrap_Ephemeris_GLONASS_svid), -1);
   rb_define_method(SwigClassEphemeris_GLONASS.klass, "freq_ch=", VALUEFUNC(_wrap_Ephemeris_GLONASS_freq_che___), -1);
@@ -27233,6 +28510,7 @@ SWIGEXPORT void Init_GPS(void) {
   rb_define_method(SwigClassEphemeris_GLONASS.klass, "frequency_L2", VALUEFUNC(_wrap_Ephemeris_GLONASS_frequency_L2), -1);
   rb_define_method(SwigClassEphemeris_GLONASS.klass, "base_time", VALUEFUNC(_wrap_Ephemeris_GLONASS_base_time), -1);
   rb_define_method(SwigClassEphemeris_GLONASS.klass, "parse", VALUEFUNC(_wrap_Ephemeris_GLONASS_parse), -1);
+  rb_define_method(SwigClassEphemeris_GLONASS.klass, "dump", VALUEFUNC(_wrap_Ephemeris_GLONASS_dump), -1);
   rb_define_method(SwigClassEphemeris_GLONASS.klass, "constellation", VALUEFUNC(_wrap_Ephemeris_GLONASS_constellation), -1);
   rb_define_method(SwigClassEphemeris_GLONASS.klass, "in_range?", VALUEFUNC(_wrap_Ephemeris_GLONASS_in_rangeq___), -1);
   SwigClassEphemeris_GLONASS.mark = 0;