gps_pvt 0.8.0 → 0.8.1

data/ext/gps_pvt/GPS/GPS_wrap.cxx

@@ -1913,9 +1913,10 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
 #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_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};
+#define SWIGTYPE_p_unsigned_int swig_types[66]
+#define SWIGTYPE_p_xyz_t swig_types[67]
+static swig_type_info *swig_types[69];
+static swig_module_info swig_module = {swig_types, 68, 0, 0, 0, 0};
 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
@@ -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();
   }
@@ -2600,6 +2613,42 @@ struct GPS_RangeCorrector
 };
 
 
+template <class BaseT, class HookT>
+struct HookableSolver : public BaseT {
+  typedef BaseT base_t;
+  HookT *hook;
+  HookableSolver(const BaseT &base) : BaseT(base), hook(NULL) {}
+  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 +2659,7 @@ struct GPS_Solver
   struct gps_t {
     GPS_SpaceNode<FloatT> space_node;
     GPS_SolverOptions<FloatT> options;
-    GPS_SinglePositioning<FloatT> solver;
+    HookableSolver<GPS_SinglePositioning<FloatT>, GPS_Solver<FloatT> > solver;
     struct ephemeris_proxy_t {
       struct item_t {
         const void *impl;
@@ -2632,19 +2681,19 @@ 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(GPS_SinglePositioning<FloatT>(space_node)), ephemeris_proxy(solver) {}
   } gps;
   struct sbas_t {
     SBAS_SpaceNode<FloatT> space_node;
     SBAS_SolverOptions<FloatT> options;
-    SBAS_SinglePositioning<FloatT> solver;
-    sbas_t() : space_node(), options(), solver(space_node) {}
+    HookableSolver<SBAS_SinglePositioning<FloatT>, GPS_Solver<FloatT> > solver;
+    sbas_t() : space_node(), options(), solver(SBAS_SinglePositioning<FloatT>(space_node)) {}
   } sbas;
   struct glonass_t {
     GLONASS_SpaceNode<FloatT> space_node;
     GLONASS_SolverOptions<FloatT> options;
-    GLONASS_SinglePositioning<FloatT> solver;
-    glonass_t() : space_node(), options(), solver(space_node) {}
+    HookableSolver<GLONASS_SinglePositioning<FloatT>, GPS_Solver<FloatT> > solver;
+    glonass_t() : space_node(), options(), solver(GLONASS_SinglePositioning<FloatT>(space_node)) {}
   } glonass;
   VALUE hooks;
   typedef std::vector<GPS_RangeCorrector<FloatT> > user_correctors_t;
@@ -2679,6 +2728,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 +2738,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 +3633,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 +3652,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 +3858,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));
@@ -3934,14 +4065,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 +4150,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 +4409,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 +4678,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 +11016,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 +11292,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 +11737,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 +11745,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 +11762,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 +11778,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 +11789,7 @@ fail:
   Document-method: GPS_PVT::GPS::Ephemeris.URA
 
   call-seq:
-    URA -> int const &
+    URA -> double const &
 
 An instance method.
 
@@ -11457,7 +11799,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 +11812,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 +11820,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,28 +14252,344 @@ 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;
+  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)) {
@@ -17450,21 +18108,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 +19632,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 +22379,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 +25473,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
 
@@ -26272,6 +27327,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[] = {
@@ -26341,6 +27397,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,
 };
 
@@ -26410,6 +27467,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[] = {
@@ -26479,6 +27537,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 +27923,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 +27936,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 +27996,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_;
@@ -27056,6 +28122,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 +28154,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 +28242,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 +28303,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;