gps_pvt 0.6.2 → 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1875,43 +1875,47 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
1875
1875
  #define SWIGTYPE_p_MatrixViewBaseT_t swig_types[25]
1876
1876
  #define SWIGTYPE_p_MatrixViewFilterT_MatrixViewBaseT_t_t swig_types[26]
1877
1877
  #define SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t swig_types[27]
1878
- #define SWIGTYPE_p_RINEX_ObservationT_double_t swig_types[28]
1879
- #define SWIGTYPE_p_SBAS_EphemerisT_double_t swig_types[29]
1880
- #define SWIGTYPE_p_SBAS_SolverOptionsT_double_t swig_types[30]
1881
- #define SWIGTYPE_p_SBAS_SpaceNodeT_double_t swig_types[31]
1882
- #define SWIGTYPE_p_SBAS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris swig_types[32]
1883
- #define SWIGTYPE_p_SP3T_double_t swig_types[33]
1884
- #define SWIGTYPE_p_System_ENUT_double_WGS84_t swig_types[34]
1885
- #define SWIGTYPE_p_System_LLHT_double_WGS84_t swig_types[35]
1886
- #define SWIGTYPE_p_System_XYZT_double_WGS84_t swig_types[36]
1887
- #define SWIGTYPE_p_available_satellites_t swig_types[37]
1888
- #define SWIGTYPE_p_char swig_types[38]
1889
- #define SWIGTYPE_p_double swig_types[39]
1890
- #define SWIGTYPE_p_enu_t swig_types[40]
1891
- #define SWIGTYPE_p_eph_t swig_types[41]
1892
- #define SWIGTYPE_p_float_t swig_types[42]
1893
- #define SWIGTYPE_p_gps_space_node_t swig_types[43]
1894
- #define SWIGTYPE_p_gps_time_t swig_types[44]
1895
- #define SWIGTYPE_p_int swig_types[45]
1896
- #define SWIGTYPE_p_int_t swig_types[46]
1897
- #define SWIGTYPE_p_llh_t swig_types[47]
1898
- #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[48]
1899
- #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[49]
1900
- #define SWIGTYPE_p_range_correction_list_t swig_types[50]
1901
- #define SWIGTYPE_p_s16_t swig_types[51]
1902
- #define SWIGTYPE_p_s32_t swig_types[52]
1903
- #define SWIGTYPE_p_s8_t swig_types[53]
1904
- #define SWIGTYPE_p_satellites_t swig_types[54]
1905
- #define SWIGTYPE_p_self_t swig_types[55]
1906
- #define SWIGTYPE_p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t swig_types[56]
1907
- #define SWIGTYPE_p_swig__GC_VALUE swig_types[57]
1908
- #define SWIGTYPE_p_u16_t swig_types[58]
1909
- #define SWIGTYPE_p_u32_t swig_types[59]
1910
- #define SWIGTYPE_p_u8_t swig_types[60]
1911
- #define SWIGTYPE_p_uint_t swig_types[61]
1912
- #define SWIGTYPE_p_xyz_t swig_types[62]
1913
- static swig_type_info *swig_types[64];
1914
- static swig_module_info swig_module = {swig_types, 63, 0, 0, 0, 0};
1878
+ #define SWIGTYPE_p_PushableData swig_types[28]
1879
+ #define SWIGTYPE_p_RINEX_ClockT_double_t swig_types[29]
1880
+ #define SWIGTYPE_p_RINEX_ObservationT_double_t swig_types[30]
1881
+ #define SWIGTYPE_p_SBAS_EphemerisT_double_t swig_types[31]
1882
+ #define SWIGTYPE_p_SBAS_SolverOptionsT_double_t swig_types[32]
1883
+ #define SWIGTYPE_p_SBAS_SpaceNodeT_double_t swig_types[33]
1884
+ #define SWIGTYPE_p_SBAS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris swig_types[34]
1885
+ #define SWIGTYPE_p_SP3T_double_t swig_types[35]
1886
+ #define SWIGTYPE_p_System_ENUT_double_WGS84_t swig_types[36]
1887
+ #define SWIGTYPE_p_System_LLHT_double_WGS84_t swig_types[37]
1888
+ #define SWIGTYPE_p_System_XYZT_double_WGS84_t swig_types[38]
1889
+ #define SWIGTYPE_p_available_satellites_t swig_types[39]
1890
+ #define SWIGTYPE_p_char swig_types[40]
1891
+ #define SWIGTYPE_p_double swig_types[41]
1892
+ #define SWIGTYPE_p_enu_t swig_types[42]
1893
+ #define SWIGTYPE_p_eph_t swig_types[43]
1894
+ #define SWIGTYPE_p_float_t swig_types[44]
1895
+ #define SWIGTYPE_p_gps_space_node_t swig_types[45]
1896
+ #define SWIGTYPE_p_gps_time_t swig_types[46]
1897
+ #define SWIGTYPE_p_int swig_types[47]
1898
+ #define SWIGTYPE_p_int_t swig_types[48]
1899
+ #define SWIGTYPE_p_llh_t swig_types[49]
1900
+ #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]
1901
+ #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]
1902
+ #define SWIGTYPE_p_p_double swig_types[52]
1903
+ #define SWIGTYPE_p_range_correction_list_t swig_types[53]
1904
+ #define SWIGTYPE_p_s16_t swig_types[54]
1905
+ #define SWIGTYPE_p_s32_t swig_types[55]
1906
+ #define SWIGTYPE_p_s8_t swig_types[56]
1907
+ #define SWIGTYPE_p_satellites_t swig_types[57]
1908
+ #define SWIGTYPE_p_self_t swig_types[58]
1909
+ #define SWIGTYPE_p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t swig_types[59]
1910
+ #define SWIGTYPE_p_super_t swig_types[60]
1911
+ #define SWIGTYPE_p_swig__GC_VALUE swig_types[61]
1912
+ #define SWIGTYPE_p_u16_t swig_types[62]
1913
+ #define SWIGTYPE_p_u32_t swig_types[63]
1914
+ #define SWIGTYPE_p_u8_t swig_types[64]
1915
+ #define SWIGTYPE_p_uint_t swig_types[65]
1916
+ #define SWIGTYPE_p_xyz_t swig_types[66]
1917
+ static swig_type_info *swig_types[68];
1918
+ static swig_module_info swig_module = {swig_types, 67, 0, 0, 0, 0};
1915
1919
  #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1916
1920
  #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1917
1921
 
@@ -1953,6 +1957,7 @@ static VALUE mGPS;
1953
1957
  #include "navigation/QZSS.h"
1954
1958
  #include "navigation/GLONASS.h"
1955
1959
  #include "navigation/RINEX.h"
1960
+ #include "navigation/RINEX_Clock.h"
1956
1961
  #include "navigation/SP3.h"
1957
1962
  #include "navigation/ANTEX.h"
1958
1963
 
@@ -2530,6 +2535,7 @@ struct GPS_Measurement {
2530
2535
 
2531
2536
  template <class FloatT>
2532
2537
  struct GPS_SolverOptions_Common {
2538
+ virtual ~GPS_SolverOptions_Common() {}
2533
2539
  virtual GPS_Solver_GeneralOptions<FloatT> *cast_general() = 0;
2534
2540
  virtual const GPS_Solver_GeneralOptions<FloatT> *cast_general() const = 0;
2535
2541
  };
@@ -2836,12 +2842,7 @@ template <class FloatT>
2836
2842
  struct RINEX_Observation {};
2837
2843
 
2838
2844
 
2839
- template <class FloatT>
2840
- struct SP3 : public SP3_Product<FloatT> {
2841
- int read(const char *fname) {
2842
- std::fstream fin(fname, std::ios::in | std::ios::binary);
2843
- return SP3_Reader<FloatT>::read_all(fin, *this);
2844
- }
2845
+ struct PushableData {
2845
2846
  enum system_t {
2846
2847
  SYS_GPS,
2847
2848
  SYS_SBAS,
@@ -2851,20 +2852,21 @@ struct SP3 : public SP3_Product<FloatT> {
2851
2852
  SYS_BEIDOU,
2852
2853
  SYS_SYSTEMS,
2853
2854
  };
2854
- bool push(GPS_Solver<FloatT> &solver, const system_t &sys) const {
2855
+ template <class DataT, class FloatT>
2856
+ static bool push(DataT &data, GPS_Solver<FloatT> &solver, const system_t &sys){
2855
2857
  switch(sys){
2856
2858
  case SYS_GPS:
2857
- return SP3_Product<FloatT>::push(
2858
- solver.gps.ephemeris_proxy.gps, SP3_Product<FloatT>::SYSTEM_GPS);
2859
+ return data.push(
2860
+ solver.gps.ephemeris_proxy.gps, DataT::SYSTEM_GPS);
2859
2861
  case SYS_SBAS:
2860
- return SP3_Product<FloatT>::push(
2861
- solver.sbas.solver.satellites, SP3_Product<FloatT>::SYSTEM_SBAS);
2862
+ return data.push(
2863
+ solver.sbas.solver.satellites, DataT::SYSTEM_SBAS);
2862
2864
  case SYS_QZSS:
2863
- return SP3_Product<FloatT>::push(
2864
- solver.gps.ephemeris_proxy.qzss, SP3_Product<FloatT>::SYSTEM_QZSS);
2865
+ return data.push(
2866
+ solver.gps.ephemeris_proxy.qzss, DataT::SYSTEM_QZSS);
2865
2867
  case SYS_GLONASS:
2866
- return SP3_Product<FloatT>::push(
2867
- solver.glonass.solver.satellites, SP3_Product<FloatT>::SYSTEM_GLONASS);
2868
+ return data.push(
2869
+ solver.glonass.solver.satellites, DataT::SYSTEM_GLONASS);
2868
2870
  case SYS_GALILEO:
2869
2871
  case SYS_BEIDOU:
2870
2872
  default:
@@ -2872,7 +2874,8 @@ struct SP3 : public SP3_Product<FloatT> {
2872
2874
  }
2873
2875
  return false;
2874
2876
  }
2875
- bool push(GPS_Solver<FloatT> &solver) const {
2877
+ template <class DataT, class FloatT>
2878
+ static bool push(DataT &data, GPS_Solver<FloatT> &solver){
2876
2879
  system_t target[] = {
2877
2880
  SYS_GPS,
2878
2881
  SYS_SBAS,
@@ -2882,10 +2885,28 @@ struct SP3 : public SP3_Product<FloatT> {
2882
2885
  //SYS_BEIDOU,
2883
2886
  };
2884
2887
  for(std::size_t i(0); i < sizeof(target) / sizeof(target[0]); ++i){
2885
- if(!push(solver, target[i])){return false;}
2888
+ if(!push(data, solver, target[i])){return false;}
2886
2889
  }
2887
2890
  return true;
2888
2891
  }
2892
+ };
2893
+
2894
+
2895
+ template <class FloatT>
2896
+ struct SP3 : public SP3_Product<FloatT>, PushableData {
2897
+ int read(const char *fname) {
2898
+ std::fstream fin(fname, std::ios::in | std::ios::binary);
2899
+ return SP3_Reader<FloatT>::read_all(fin, *this);
2900
+ }
2901
+ typename SP3_Product<FloatT>::satellite_count_t satellites() const {
2902
+ return SP3_Product<FloatT>::satellite_count();
2903
+ }
2904
+ bool push(GPS_Solver<FloatT> &solver, const PushableData::system_t &sys) const {
2905
+ return PushableData::push((SP3_Product<FloatT> &)*this, solver, sys);
2906
+ }
2907
+ bool push(GPS_Solver<FloatT> &solver) const {
2908
+ return PushableData::push((SP3_Product<FloatT> &)*this, solver);
2909
+ }
2889
2910
  System_XYZ<FloatT, WGS84> position(
2890
2911
  const int &sat_id, const GPS_Time<FloatT> &t) const {
2891
2912
  return SP3_Product<FloatT>::select(sat_id, t).position(t);
@@ -2912,6 +2933,35 @@ struct SP3 : public SP3_Product<FloatT> {
2912
2933
  };
2913
2934
 
2914
2935
 
2936
+ template <class FloatT>
2937
+ struct RINEX_Clock : public RINEX_CLK<FloatT>::satellites_t, PushableData {
2938
+ typedef typename RINEX_CLK<FloatT>::satellites_t super_t;
2939
+ int read(const char *fname) {
2940
+ std::fstream fin(fname, std::ios::in | std::ios::binary);
2941
+ return RINEX_CLK_Reader<FloatT>::read_all(fin, *this);
2942
+ }
2943
+ typename RINEX_CLK<FloatT>::satellites_t::count_t satellites() const {
2944
+ return RINEX_CLK<FloatT>::satellites_t::count();
2945
+ }
2946
+ bool push(GPS_Solver<FloatT> &solver, const PushableData::system_t &sys) const {
2947
+ return PushableData::push((typename RINEX_CLK<FloatT>::satellites_t &)*this, solver, sys);
2948
+ }
2949
+ bool push(GPS_Solver<FloatT> &solver) const {
2950
+ return PushableData::push((typename RINEX_CLK<FloatT>::satellites_t &)*this, solver);
2951
+ }
2952
+ FloatT clock_error(const int &sat_id, const GPS_Time<FloatT> &t) const {
2953
+ typename super_t::buf_t::const_iterator it(this->buf.find(sat_id));
2954
+ if(it == this->buf.end()){return super_t::sat_t::unavailable().clock_error(t);}
2955
+ return it->second.clock_error(t);
2956
+ }
2957
+ FloatT clock_error_dot(const int &sat_id, const GPS_Time<FloatT> &t) const {
2958
+ typename super_t::buf_t::const_iterator it(this->buf.find(sat_id));
2959
+ if(it == this->buf.end()){return super_t::sat_t::unavailable().clock_error(t);}
2960
+ return it->second.clock_error_dot(t);
2961
+ }
2962
+ };
2963
+
2964
+
2915
2965
  SWIGINTERNINLINE VALUE
2916
2966
  SWIG_From_unsigned_SS_long (unsigned long value)
2917
2967
  {
@@ -3448,21 +3498,13 @@ SWIGINTERN void GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__set_alpha(GPS_Ionos
3448
3498
  self->alpha[i] = values[i];
3449
3499
  }
3450
3500
  }
3451
- SWIGINTERN void GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__get_alpha(GPS_Ionospheric_UTC_Parameters< double > const *self,double values[4]){
3452
- for(int i(0); i < 4; ++i){
3453
- values[i] = self->alpha[i];
3454
- }
3455
- }
3501
+ SWIGINTERN void GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__get_alpha(GPS_Ionospheric_UTC_Parameters< double > const *self,double const *values[4]){*values = self->alpha;}
3456
3502
  SWIGINTERN void GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__set_beta(GPS_Ionospheric_UTC_Parameters< double > *self,double const values[4]){
3457
3503
  for(int i(0); i < 4; ++i){
3458
3504
  self->beta[i] = values[i];
3459
3505
  }
3460
3506
  }
3461
- SWIGINTERN void GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__get_beta(GPS_Ionospheric_UTC_Parameters< double > const *self,double values[4]){
3462
- for(int i(0); i < 4; ++i){
3463
- values[i] = self->beta[i];
3464
- }
3465
- }
3507
+ SWIGINTERN void GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__get_beta(GPS_Ionospheric_UTC_Parameters< double > const *self,double const *values[4]){*values = self->beta;}
3466
3508
  SWIGINTERN double GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__set_A1(GPS_Ionospheric_UTC_Parameters< double > *self,double const &v){
3467
3509
  return self->A1 = v;
3468
3510
  }
@@ -3980,7 +4022,10 @@ SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_residual_mas
3980
4022
  if(!res.is_available()){
3981
4023
  static const VALUE key(ID2SYM(rb_intern("relative_property")));
3982
4024
  VALUE hook(rb_hash_lookup(hooks, key));
3983
- if(!NIL_P(hook)){res.impl = this;}
4025
+ if(!NIL_P(hook)){
4026
+ if(!res.impl_xyz){res.impl_xyz = this;}
4027
+ if(!res.impl_t){res.impl_t = this;}
4028
+ }
3984
4029
  }
3985
4030
 
3986
4031
  return res;
@@ -4578,15 +4623,6 @@ SWIGINTERN void RINEX_Observation_Sl_double_Sg__read(char const *fname){
4578
4623
 
4579
4624
  }
4580
4625
  }
4581
- SWIGINTERN void SP3_Sl_double_Sg__satellites(SP3< double > const *self,int count[SP3< double >::SYS_SYSTEMS]){
4582
- typename SP3_Product<double>::satellite_count_t x(self->satellite_count());
4583
- count[SP3<double>::SYS_GPS] = x.gps;
4584
- count[SP3<double>::SYS_SBAS] = x.sbas;
4585
- count[SP3<double>::SYS_QZSS] = x.qzss;
4586
- count[SP3<double>::SYS_GLONASS] = x.glonass;
4587
- count[SP3<double>::SYS_GALILEO] = x.galileo;
4588
- count[SP3<double>::SYS_BEIDOU] = x.beidou;
4589
- }
4590
4626
  static swig_class SwigClassGC_VALUE;
4591
4627
 
4592
4628
  /*
@@ -4643,6 +4679,132 @@ fail:
4643
4679
  }
4644
4680
 
4645
4681
 
4682
+ /*
4683
+ Document-class: GPS_PVT::GPS::PushableData
4684
+
4685
+ Proxy of C++ GPS_PVT::GPS::PushableData class
4686
+
4687
+
4688
+ */
4689
+ static swig_class SwigClassPushableData;
4690
+
4691
+ /*
4692
+ Document-method: GPS_PVT::GPS::system_t.SYS_GPS
4693
+
4694
+ call-seq:
4695
+ SYS_GPS -> int
4696
+
4697
+ A class method.
4698
+
4699
+ */
4700
+ /*
4701
+ Document-method: GPS_PVT::GPS::system_t.SYS_SBAS
4702
+
4703
+ call-seq:
4704
+ SYS_SBAS -> int
4705
+
4706
+ A class method.
4707
+
4708
+ */
4709
+ /*
4710
+ Document-method: GPS_PVT::GPS::system_t.SYS_QZSS
4711
+
4712
+ call-seq:
4713
+ SYS_QZSS -> int
4714
+
4715
+ A class method.
4716
+
4717
+ */
4718
+ /*
4719
+ Document-method: GPS_PVT::GPS::system_t.SYS_GLONASS
4720
+
4721
+ call-seq:
4722
+ SYS_GLONASS -> int
4723
+
4724
+ A class method.
4725
+
4726
+ */
4727
+ /*
4728
+ Document-method: GPS_PVT::GPS::system_t.SYS_GALILEO
4729
+
4730
+ call-seq:
4731
+ SYS_GALILEO -> int
4732
+
4733
+ A class method.
4734
+
4735
+ */
4736
+ /*
4737
+ Document-method: GPS_PVT::GPS::system_t.SYS_BEIDOU
4738
+
4739
+ call-seq:
4740
+ SYS_BEIDOU -> int
4741
+
4742
+ A class method.
4743
+
4744
+ */
4745
+ /*
4746
+ Document-method: GPS_PVT::GPS::system_t.SYS_SYSTEMS
4747
+
4748
+ call-seq:
4749
+ SYS_SYSTEMS -> int
4750
+
4751
+ A class method.
4752
+
4753
+ */
4754
+ SWIGINTERN VALUE
4755
+ #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
4756
+ _wrap_PushableData_allocate(VALUE self)
4757
+ #else
4758
+ _wrap_PushableData_allocate(int argc, VALUE *argv, VALUE self)
4759
+ #endif
4760
+ {
4761
+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_PushableData);
4762
+ #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
4763
+ rb_obj_call_init(vresult, argc, argv);
4764
+ #endif
4765
+ return vresult;
4766
+ }
4767
+
4768
+
4769
+ /*
4770
+ Document-method: GPS_PVT::GPS::PushableData.new
4771
+
4772
+ call-seq:
4773
+ PushableData.new
4774
+
4775
+ Class constructor.
4776
+
4777
+ */
4778
+ SWIGINTERN VALUE
4779
+ _wrap_new_PushableData(int argc, VALUE *argv, VALUE self) {
4780
+ PushableData *result = 0 ;
4781
+
4782
+ if ((argc < 0) || (argc > 0)) {
4783
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4784
+ }
4785
+ {
4786
+ try {
4787
+ result = (PushableData *)new PushableData();
4788
+ DATA_PTR(self) = result;
4789
+ } catch (const native_exception &e) {
4790
+ e.regenerate();
4791
+ SWIG_fail;
4792
+ } catch (const std::exception& e) {
4793
+ SWIG_exception_fail(SWIG_RuntimeError, e.what());
4794
+ }
4795
+ }
4796
+ return self;
4797
+ fail:
4798
+ return Qnil;
4799
+ }
4800
+
4801
+
4802
+ SWIGINTERN void
4803
+ free_PushableData(void *self) {
4804
+ PushableData *arg1 = (PushableData *)self;
4805
+ delete arg1;
4806
+ }
4807
+
4646
4808
  /*
4647
4809
  Document-class: GPS_PVT::GPS::Time
4648
4810
 
@@ -9708,7 +9870,6 @@ _wrap_Ionospheric_UTC_Parameters_alphae___(int argc, VALUE *argv, VALUE self) {
9708
9870
  void *argp1 = 0 ;
9709
9871
  int res1 = 0 ;
9710
9872
  double temp2[4] ;
9711
- VALUE vresult = Qnil;
9712
9873
 
9713
9874
  if ((argc < 1) || (argc > 1)) {
9714
9875
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
@@ -9739,12 +9900,7 @@ _wrap_Ionospheric_UTC_Parameters_alphae___(int argc, VALUE *argv, VALUE self) {
9739
9900
  SWIG_exception_fail(SWIG_RuntimeError, e.what());
9740
9901
  }
9741
9902
  }
9742
- {
9743
- for(int i(0); i < 4; ++i){
9744
- vresult = SWIG_Ruby_AppendOutput(vresult, swig::from(arg2[i]));
9745
- }
9746
- }
9747
- return vresult;
9903
+ return Qnil;
9748
9904
  fail:
9749
9905
  return Qnil;
9750
9906
  }
@@ -9762,15 +9918,13 @@ An instance method.
9762
9918
  SWIGINTERN VALUE
9763
9919
  _wrap_Ionospheric_UTC_Parameters_alpha(int argc, VALUE *argv, VALUE self) {
9764
9920
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< double > *) 0 ;
9765
- double *arg2 ;
9921
+ double **arg2 ;
9766
9922
  void *argp1 = 0 ;
9767
9923
  int res1 = 0 ;
9768
- double temp2[4] ;
9924
+ double *temp2 ;
9769
9925
  VALUE vresult = Qnil;
9770
9926
 
9771
-
9772
- arg2 = temp2;
9773
-
9927
+ arg2 = &temp2;
9774
9928
  if ((argc < 0) || (argc > 0)) {
9775
9929
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9776
9930
  }
@@ -9781,7 +9935,7 @@ _wrap_Ionospheric_UTC_Parameters_alpha(int argc, VALUE *argv, VALUE self) {
9781
9935
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< double > * >(argp1);
9782
9936
  {
9783
9937
  try {
9784
- GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__get_alpha((GPS_Ionospheric_UTC_Parameters< double > const *)arg1,arg2);
9938
+ GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__get_alpha((GPS_Ionospheric_UTC_Parameters< double > const *)arg1,(double const *(*))arg2);
9785
9939
  } catch (const native_exception &e) {
9786
9940
  e.regenerate();
9787
9941
  SWIG_fail;
@@ -9791,7 +9945,7 @@ _wrap_Ionospheric_UTC_Parameters_alpha(int argc, VALUE *argv, VALUE self) {
9791
9945
  }
9792
9946
  {
9793
9947
  for(int i(0); i < 4; ++i){
9794
- vresult = SWIG_Ruby_AppendOutput(vresult, swig::from(arg2[i]));
9948
+ vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)[i]));
9795
9949
  }
9796
9950
  }
9797
9951
  return vresult;
@@ -9816,7 +9970,6 @@ _wrap_Ionospheric_UTC_Parameters_betae___(int argc, VALUE *argv, VALUE self) {
9816
9970
  void *argp1 = 0 ;
9817
9971
  int res1 = 0 ;
9818
9972
  double temp2[4] ;
9819
- VALUE vresult = Qnil;
9820
9973
 
9821
9974
  if ((argc < 1) || (argc > 1)) {
9822
9975
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
@@ -9847,12 +10000,7 @@ _wrap_Ionospheric_UTC_Parameters_betae___(int argc, VALUE *argv, VALUE self) {
9847
10000
  SWIG_exception_fail(SWIG_RuntimeError, e.what());
9848
10001
  }
9849
10002
  }
9850
- {
9851
- for(int i(0); i < 4; ++i){
9852
- vresult = SWIG_Ruby_AppendOutput(vresult, swig::from(arg2[i]));
9853
- }
9854
- }
9855
- return vresult;
10003
+ return Qnil;
9856
10004
  fail:
9857
10005
  return Qnil;
9858
10006
  }
@@ -9870,15 +10018,13 @@ An instance method.
9870
10018
  SWIGINTERN VALUE
9871
10019
  _wrap_Ionospheric_UTC_Parameters_beta(int argc, VALUE *argv, VALUE self) {
9872
10020
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< double > *) 0 ;
9873
- double *arg2 ;
10021
+ double **arg2 ;
9874
10022
  void *argp1 = 0 ;
9875
10023
  int res1 = 0 ;
9876
- double temp2[4] ;
10024
+ double *temp2 ;
9877
10025
  VALUE vresult = Qnil;
9878
10026
 
9879
-
9880
- arg2 = temp2;
9881
-
10027
+ arg2 = &temp2;
9882
10028
  if ((argc < 0) || (argc > 0)) {
9883
10029
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9884
10030
  }
@@ -9889,7 +10035,7 @@ _wrap_Ionospheric_UTC_Parameters_beta(int argc, VALUE *argv, VALUE self) {
9889
10035
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< double > * >(argp1);
9890
10036
  {
9891
10037
  try {
9892
- GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__get_beta((GPS_Ionospheric_UTC_Parameters< double > const *)arg1,arg2);
10038
+ GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__get_beta((GPS_Ionospheric_UTC_Parameters< double > const *)arg1,(double const *(*))arg2);
9893
10039
  } catch (const native_exception &e) {
9894
10040
  e.regenerate();
9895
10041
  SWIG_fail;
@@ -9899,7 +10045,7 @@ _wrap_Ionospheric_UTC_Parameters_beta(int argc, VALUE *argv, VALUE self) {
9899
10045
  }
9900
10046
  {
9901
10047
  for(int i(0); i < 4; ++i){
9902
- vresult = SWIG_Ruby_AppendOutput(vresult, swig::from(arg2[i]));
10048
+ vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)[i]));
9903
10049
  }
9904
10050
  }
9905
10051
  return vresult;
@@ -16071,6 +16217,12 @@ free_GPS_Measurement_Sl_double_Sg_(void *self) {
16071
16217
  */
16072
16218
  static swig_class SwigClassSolverOptionsCommon;
16073
16219
 
16220
+ SWIGINTERN void
16221
+ free_GPS_SolverOptions_Common_Sl_double_Sg_(void *self) {
16222
+ GPS_SolverOptions_Common< double > *arg1 = (GPS_SolverOptions_Common< double > *)self;
16223
+ delete arg1;
16224
+ }
16225
+
16074
16226
  /*
16075
16227
  Document-method: GPS_PVT::GPS::SolverOptionsCommon.cast_general
16076
16228
 
@@ -16374,12 +16526,6 @@ fail:
16374
16526
  }
16375
16527
 
16376
16528
 
16377
- SWIGINTERN void
16378
- free_GPS_SolverOptions_Common_Sl_double_Sg_(void *self) {
16379
- GPS_SolverOptions_Common< double > *arg1 = (GPS_SolverOptions_Common< double > *)self;
16380
- delete arg1;
16381
- }
16382
-
16383
16529
  /*
16384
16530
  Document-class: GPS_PVT::GPS::SolverOptions < GPS::SolverOptionsCommon
16385
16531
 
@@ -24889,89 +25035,75 @@ fail:
24889
25035
 
24890
25036
 
24891
25037
  /*
24892
- Document-method: GPS_PVT::GPS::system_t.SYS_GPS
24893
-
24894
- call-seq:
24895
- SYS_GPS -> int
24896
-
24897
- A class method.
24898
-
24899
- */
24900
- /*
24901
- Document-method: GPS_PVT::GPS::system_t.SYS_SBAS
24902
-
24903
- call-seq:
24904
- SYS_SBAS -> int
24905
-
24906
- A class method.
24907
-
24908
- */
24909
- /*
24910
- Document-method: GPS_PVT::GPS::system_t.SYS_QZSS
25038
+ Document-method: GPS_PVT::GPS::SP3.satellites
24911
25039
 
24912
25040
  call-seq:
24913
- SYS_QZSS -> int
25041
+ satellites -> SP3_Product< double >::satellite_count_t
24914
25042
 
24915
- A class method.
25043
+ An instance method.
24916
25044
 
24917
25045
  */
24918
- /*
24919
- Document-method: GPS_PVT::GPS::system_t.SYS_GLONASS
24920
-
24921
- call-seq:
24922
- SYS_GLONASS -> int
25046
+ SWIGINTERN VALUE
25047
+ _wrap_SP3_satellites(int argc, VALUE *argv, VALUE self) {
25048
+ SP3< double > *arg1 = (SP3< double > *) 0 ;
25049
+ void *argp1 = 0 ;
25050
+ int res1 = 0 ;
25051
+ SP3_Product< double >::satellite_count_t result;
25052
+ VALUE vresult = Qnil;
25053
+
25054
+ if ((argc < 0) || (argc > 0)) {
25055
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
25056
+ }
25057
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SP3T_double_t, 0 | 0 );
25058
+ if (!SWIG_IsOK(res1)) {
25059
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SP3< double > const *","satellites", 1, self ));
25060
+ }
25061
+ arg1 = reinterpret_cast< SP3< double > * >(argp1);
25062
+ {
25063
+ try {
25064
+ result = ((SP3< double > const *)arg1)->satellites();
25065
+ } catch (const native_exception &e) {
25066
+ e.regenerate();
25067
+ SWIG_fail;
25068
+ } catch (const std::exception& e) {
25069
+ SWIG_exception_fail(SWIG_RuntimeError, e.what());
25070
+ }
25071
+ }
25072
+ {
25073
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int ((&result)->gps));
25074
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int ((&result)->sbas));
25075
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int ((&result)->qzss));
25076
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int ((&result)->glonass));
25077
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int ((&result)->galileo));
25078
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int ((&result)->beidou));
25079
+ }
25080
+ return vresult;
25081
+ fail:
25082
+ return Qnil;
25083
+ }
24923
25084
 
24924
- A class method.
24925
25085
 
24926
- */
24927
25086
  /*
24928
- Document-method: GPS_PVT::GPS::system_t.SYS_GALILEO
25087
+ Document-method: GPS_PVT::GPS::SP3.push
24929
25088
 
24930
25089
  call-seq:
24931
- SYS_GALILEO -> int
24932
-
24933
- A class method.
25090
+ push(solver, sys) -> bool
25091
+ push(solver) -> bool
24934
25092
 
24935
- */
24936
- /*
24937
- Document-method: GPS_PVT::GPS::system_t.SYS_BEIDOU
24938
-
24939
- call-seq:
24940
- SYS_BEIDOU -> int
24941
-
24942
- A class method.
24943
-
24944
- */
24945
- /*
24946
- Document-method: GPS_PVT::GPS::system_t.SYS_SYSTEMS
24947
-
24948
- call-seq:
24949
- SYS_SYSTEMS -> int
24950
-
24951
- A class method.
24952
-
24953
- */
24954
- /*
24955
- Document-method: GPS_PVT::GPS::SP3.push
24956
-
24957
- call-seq:
24958
- push(solver, sys) -> bool
24959
- push(solver) -> bool
24960
-
24961
- Add an element at the end of the SP3.
25093
+ Add an element at the end of the SP3.
24962
25094
  */
24963
25095
  SWIGINTERN VALUE
24964
25096
  _wrap_SP3_push__SWIG_0(int argc, VALUE *argv, VALUE self) {
24965
25097
  SP3< double > *arg1 = (SP3< double > *) 0 ;
24966
25098
  GPS_Solver< double > *arg2 = 0 ;
24967
- SP3< double >::system_t *arg3 = 0 ;
25099
+ PushableData::system_t *arg3 = 0 ;
24968
25100
  void *argp1 = 0 ;
24969
25101
  int res1 = 0 ;
24970
25102
  void *argp2 = 0 ;
24971
25103
  int res2 = 0 ;
24972
25104
  int val3 ;
24973
25105
  int ecode3 ;
24974
- SP3< double >::system_t temp3 ;
25106
+ PushableData::system_t temp3 ;
24975
25107
  bool result;
24976
25108
  VALUE vresult = Qnil;
24977
25109
 
@@ -24993,14 +25125,14 @@ _wrap_SP3_push__SWIG_0(int argc, VALUE *argv, VALUE self) {
24993
25125
  arg2 = reinterpret_cast< GPS_Solver< double > * >(argp2);
24994
25126
  ecode3 = SWIG_AsVal_int (argv[1], &val3);
24995
25127
  if (!SWIG_IsOK(ecode3)) {
24996
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "SP3< double >::system_t const &","push", 3, argv[1] ));
25128
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "PushableData::system_t const &","push", 3, argv[1] ));
24997
25129
  } else {
24998
- temp3 = static_cast< SP3< double >::system_t >(val3);
25130
+ temp3 = static_cast< PushableData::system_t >(val3);
24999
25131
  arg3 = &temp3;
25000
25132
  }
25001
25133
  {
25002
25134
  try {
25003
- result = (bool)((SP3< double > const *)arg1)->push(*arg2,(SP3< double >::system_t const &)*arg3);
25135
+ result = (bool)((SP3< double > const *)arg1)->push(*arg2,(PushableData::system_t const &)*arg3);
25004
25136
  } catch (const native_exception &e) {
25005
25137
  e.regenerate();
25006
25138
  SWIG_fail;
@@ -25107,7 +25239,7 @@ SWIGINTERN VALUE _wrap_SP3_push(int nargs, VALUE *args, VALUE self) {
25107
25239
 
25108
25240
  fail:
25109
25241
  Ruby_Format_OverloadedError( argc, 4, "SP3.push",
25110
- " bool SP3.push(GPS_Solver< double > &solver, SP3< double >::system_t const &sys)\n"
25242
+ " bool SP3.push(GPS_Solver< double > &solver, PushableData::system_t const &sys)\n"
25111
25243
  " bool SP3.push(GPS_Solver< double > &solver)\n");
25112
25244
 
25113
25245
  return Qnil;
@@ -25419,36 +25551,151 @@ fail:
25419
25551
  }
25420
25552
 
25421
25553
 
25554
+ SWIGINTERN VALUE
25555
+ #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
25556
+ _wrap_SP3_allocate(VALUE self)
25557
+ #else
25558
+ _wrap_SP3_allocate(int argc, VALUE *argv, VALUE self)
25559
+ #endif
25560
+ {
25561
+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_SP3T_double_t);
25562
+ #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
25563
+ rb_obj_call_init(vresult, argc, argv);
25564
+ #endif
25565
+ return vresult;
25566
+ }
25567
+
25568
+
25422
25569
  /*
25423
- Document-method: GPS_PVT::GPS::SP3.satellites
25570
+ Document-method: GPS_PVT::GPS::SP3.new
25571
+
25572
+ call-seq:
25573
+ SP3.new
25574
+
25575
+ Class constructor.
25576
+
25577
+ */
25578
+ SWIGINTERN VALUE
25579
+ _wrap_new_SP3(int argc, VALUE *argv, VALUE self) {
25580
+ SP3< double > *result = 0 ;
25581
+
25582
+ if ((argc < 0) || (argc > 0)) {
25583
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
25584
+ }
25585
+ {
25586
+ try {
25587
+ result = (SP3< double > *)new SP3< double >();
25588
+ DATA_PTR(self) = result;
25589
+ } catch (const native_exception &e) {
25590
+ e.regenerate();
25591
+ SWIG_fail;
25592
+ } catch (const std::exception& e) {
25593
+ SWIG_exception_fail(SWIG_RuntimeError, e.what());
25594
+ }
25595
+ }
25596
+ return self;
25597
+ fail:
25598
+ return Qnil;
25599
+ }
25600
+
25601
+
25602
+ SWIGINTERN void
25603
+ free_SP3_Sl_double_Sg_(void *self) {
25604
+ SP3< double > *arg1 = (SP3< double > *)self;
25605
+ delete arg1;
25606
+ }
25607
+
25608
+ /*
25609
+ Document-class: GPS_PVT::GPS
25610
+
25611
+ Proxy of C++ GPS_PVT::GPS class
25612
+
25613
+
25614
+
25615
+ */
25616
+ static swig_class SwigClassRINEX_Clock;
25617
+
25618
+ /*
25619
+ Document-method: GPS_PVT::GPS::RINEX_Clock.read
25424
25620
 
25425
25621
  call-seq:
25426
- satellites
25622
+ read(char const * fname) -> int
25427
25623
 
25428
25624
  An instance method.
25429
25625
 
25430
25626
  */
25431
25627
  SWIGINTERN VALUE
25432
- _wrap_SP3_satellites(int argc, VALUE *argv, VALUE self) {
25433
- SP3< double > *arg1 = (SP3< double > *) 0 ;
25434
- int *arg2 ;
25628
+ _wrap_RINEX_Clock_read(int argc, VALUE *argv, VALUE self) {
25629
+ RINEX_Clock< double > *arg1 = (RINEX_Clock< double > *) 0 ;
25630
+ char *arg2 = (char *) 0 ;
25631
+ void *argp1 = 0 ;
25632
+ int res1 = 0 ;
25633
+ int res2 ;
25634
+ char *buf2 = 0 ;
25635
+ int alloc2 = 0 ;
25636
+ int result;
25637
+ VALUE vresult = Qnil;
25638
+
25639
+ if ((argc < 1) || (argc > 1)) {
25640
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
25641
+ }
25642
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RINEX_ClockT_double_t, 0 | 0 );
25643
+ if (!SWIG_IsOK(res1)) {
25644
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "RINEX_Clock< double > *","read", 1, self ));
25645
+ }
25646
+ arg1 = reinterpret_cast< RINEX_Clock< double > * >(argp1);
25647
+ res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
25648
+ if (!SWIG_IsOK(res2)) {
25649
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","read", 2, argv[0] ));
25650
+ }
25651
+ arg2 = reinterpret_cast< char * >(buf2);
25652
+ {
25653
+ try {
25654
+ result = (int)(arg1)->read((char const *)arg2);
25655
+ } catch (const native_exception &e) {
25656
+ e.regenerate();
25657
+ SWIG_fail;
25658
+ } catch (const std::exception& e) {
25659
+ SWIG_exception_fail(SWIG_RuntimeError, e.what());
25660
+ }
25661
+ }
25662
+ vresult = SWIG_From_int(static_cast< int >(result));
25663
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25664
+ return vresult;
25665
+ fail:
25666
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25667
+ return Qnil;
25668
+ }
25669
+
25670
+
25671
+ /*
25672
+ Document-method: GPS_PVT::GPS::RINEX_Clock.satellites
25673
+
25674
+ call-seq:
25675
+ satellites -> RINEX_CLK< double >::satellites_t::count_t
25676
+
25677
+ An instance method.
25678
+
25679
+ */
25680
+ SWIGINTERN VALUE
25681
+ _wrap_RINEX_Clock_satellites(int argc, VALUE *argv, VALUE self) {
25682
+ RINEX_Clock< double > *arg1 = (RINEX_Clock< double > *) 0 ;
25435
25683
  void *argp1 = 0 ;
25436
25684
  int res1 = 0 ;
25437
- int temp2[SP3< double >::SYS_SYSTEMS] ;
25685
+ RINEX_CLK< double >::satellites_t::count_t result;
25438
25686
  VALUE vresult = Qnil;
25439
25687
 
25440
- arg2 = temp2;
25441
25688
  if ((argc < 0) || (argc > 0)) {
25442
25689
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
25443
25690
  }
25444
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SP3T_double_t, 0 | 0 );
25691
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RINEX_ClockT_double_t, 0 | 0 );
25445
25692
  if (!SWIG_IsOK(res1)) {
25446
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SP3< double > const *","satellites", 1, self ));
25693
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "RINEX_Clock< double > const *","satellites", 1, self ));
25447
25694
  }
25448
- arg1 = reinterpret_cast< SP3< double > * >(argp1);
25695
+ arg1 = reinterpret_cast< RINEX_Clock< double > * >(argp1);
25449
25696
  {
25450
25697
  try {
25451
- SP3_Sl_double_Sg__satellites((SP3< double > const *)arg1,arg2);
25698
+ result = ((RINEX_Clock< double > const *)arg1)->satellites();
25452
25699
  } catch (const native_exception &e) {
25453
25700
  e.regenerate();
25454
25701
  SWIG_fail;
@@ -25457,10 +25704,302 @@ _wrap_SP3_satellites(int argc, VALUE *argv, VALUE self) {
25457
25704
  }
25458
25705
  }
25459
25706
  {
25460
- for(int i(0); i < SP3< double >::SYS_SYSTEMS; ++i){
25461
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int (arg2[i]));
25707
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int ((&result)->gps));
25708
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int ((&result)->sbas));
25709
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int ((&result)->qzss));
25710
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int ((&result)->glonass));
25711
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int ((&result)->galileo));
25712
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int ((&result)->beidou));
25713
+ }
25714
+ return vresult;
25715
+ fail:
25716
+ return Qnil;
25717
+ }
25718
+
25719
+
25720
+ /*
25721
+ Document-method: GPS_PVT::GPS::RINEX_Clock.push
25722
+
25723
+ call-seq:
25724
+ push(solver, sys) -> bool
25725
+ push(solver) -> bool
25726
+
25727
+ Add an element at the end of the RINEX_Clock.
25728
+ */
25729
+ SWIGINTERN VALUE
25730
+ _wrap_RINEX_Clock_push__SWIG_0(int argc, VALUE *argv, VALUE self) {
25731
+ RINEX_Clock< double > *arg1 = (RINEX_Clock< double > *) 0 ;
25732
+ GPS_Solver< double > *arg2 = 0 ;
25733
+ PushableData::system_t *arg3 = 0 ;
25734
+ void *argp1 = 0 ;
25735
+ int res1 = 0 ;
25736
+ void *argp2 = 0 ;
25737
+ int res2 = 0 ;
25738
+ int val3 ;
25739
+ int ecode3 ;
25740
+ PushableData::system_t temp3 ;
25741
+ bool result;
25742
+ VALUE vresult = Qnil;
25743
+
25744
+ if ((argc < 2) || (argc > 2)) {
25745
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
25746
+ }
25747
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RINEX_ClockT_double_t, 0 | 0 );
25748
+ if (!SWIG_IsOK(res1)) {
25749
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "RINEX_Clock< double > const *","push", 1, self ));
25750
+ }
25751
+ arg1 = reinterpret_cast< RINEX_Clock< double > * >(argp1);
25752
+ res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPS_SolverT_double_t, 0 );
25753
+ if (!SWIG_IsOK(res2)) {
25754
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_Solver< double > &","push", 2, argv[0] ));
25755
+ }
25756
+ if (!argp2) {
25757
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Solver< double > &","push", 2, argv[0]));
25758
+ }
25759
+ arg2 = reinterpret_cast< GPS_Solver< double > * >(argp2);
25760
+ ecode3 = SWIG_AsVal_int (argv[1], &val3);
25761
+ if (!SWIG_IsOK(ecode3)) {
25762
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "PushableData::system_t const &","push", 3, argv[1] ));
25763
+ } else {
25764
+ temp3 = static_cast< PushableData::system_t >(val3);
25765
+ arg3 = &temp3;
25766
+ }
25767
+ {
25768
+ try {
25769
+ result = (bool)((RINEX_Clock< double > const *)arg1)->push(*arg2,(PushableData::system_t const &)*arg3);
25770
+ } catch (const native_exception &e) {
25771
+ e.regenerate();
25772
+ SWIG_fail;
25773
+ } catch (const std::exception& e) {
25774
+ SWIG_exception_fail(SWIG_RuntimeError, e.what());
25462
25775
  }
25463
25776
  }
25777
+ vresult = SWIG_From_bool(static_cast< bool >(result));
25778
+ return vresult;
25779
+ fail:
25780
+ return Qnil;
25781
+ }
25782
+
25783
+
25784
+ SWIGINTERN VALUE
25785
+ _wrap_RINEX_Clock_push__SWIG_1(int argc, VALUE *argv, VALUE self) {
25786
+ RINEX_Clock< double > *arg1 = (RINEX_Clock< double > *) 0 ;
25787
+ GPS_Solver< double > *arg2 = 0 ;
25788
+ void *argp1 = 0 ;
25789
+ int res1 = 0 ;
25790
+ void *argp2 = 0 ;
25791
+ int res2 = 0 ;
25792
+ bool result;
25793
+ VALUE vresult = Qnil;
25794
+
25795
+ if ((argc < 1) || (argc > 1)) {
25796
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
25797
+ }
25798
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RINEX_ClockT_double_t, 0 | 0 );
25799
+ if (!SWIG_IsOK(res1)) {
25800
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "RINEX_Clock< double > const *","push", 1, self ));
25801
+ }
25802
+ arg1 = reinterpret_cast< RINEX_Clock< double > * >(argp1);
25803
+ res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPS_SolverT_double_t, 0 );
25804
+ if (!SWIG_IsOK(res2)) {
25805
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_Solver< double > &","push", 2, argv[0] ));
25806
+ }
25807
+ if (!argp2) {
25808
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Solver< double > &","push", 2, argv[0]));
25809
+ }
25810
+ arg2 = reinterpret_cast< GPS_Solver< double > * >(argp2);
25811
+ {
25812
+ try {
25813
+ result = (bool)((RINEX_Clock< double > const *)arg1)->push(*arg2);
25814
+ } catch (const native_exception &e) {
25815
+ e.regenerate();
25816
+ SWIG_fail;
25817
+ } catch (const std::exception& e) {
25818
+ SWIG_exception_fail(SWIG_RuntimeError, e.what());
25819
+ }
25820
+ }
25821
+ vresult = SWIG_From_bool(static_cast< bool >(result));
25822
+ return vresult;
25823
+ fail:
25824
+ return Qnil;
25825
+ }
25826
+
25827
+
25828
+ SWIGINTERN VALUE _wrap_RINEX_Clock_push(int nargs, VALUE *args, VALUE self) {
25829
+ int argc;
25830
+ VALUE argv[4];
25831
+ int ii;
25832
+
25833
+ argc = nargs + 1;
25834
+ argv[0] = self;
25835
+ if (argc > 4) SWIG_fail;
25836
+ for (ii = 1; (ii < argc); ++ii) {
25837
+ argv[ii] = args[ii-1];
25838
+ }
25839
+ if (argc == 2) {
25840
+ int _v;
25841
+ void *vptr = 0;
25842
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_RINEX_ClockT_double_t, 0);
25843
+ _v = SWIG_CheckState(res);
25844
+ if (_v) {
25845
+ void *vptr = 0;
25846
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPS_SolverT_double_t, SWIG_POINTER_NO_NULL);
25847
+ _v = SWIG_CheckState(res);
25848
+ if (_v) {
25849
+ return _wrap_RINEX_Clock_push__SWIG_1(nargs, args, self);
25850
+ }
25851
+ }
25852
+ }
25853
+ if (argc == 3) {
25854
+ int _v;
25855
+ void *vptr = 0;
25856
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_RINEX_ClockT_double_t, 0);
25857
+ _v = SWIG_CheckState(res);
25858
+ if (_v) {
25859
+ void *vptr = 0;
25860
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPS_SolverT_double_t, SWIG_POINTER_NO_NULL);
25861
+ _v = SWIG_CheckState(res);
25862
+ if (_v) {
25863
+ {
25864
+ int res = SWIG_AsVal_int(argv[2], NULL);
25865
+ _v = SWIG_CheckState(res);
25866
+ }
25867
+ if (_v) {
25868
+ return _wrap_RINEX_Clock_push__SWIG_0(nargs, args, self);
25869
+ }
25870
+ }
25871
+ }
25872
+ }
25873
+
25874
+ fail:
25875
+ Ruby_Format_OverloadedError( argc, 4, "RINEX_Clock.push",
25876
+ " bool RINEX_Clock.push(GPS_Solver< double > &solver, PushableData::system_t const &sys)\n"
25877
+ " bool RINEX_Clock.push(GPS_Solver< double > &solver)\n");
25878
+
25879
+ return Qnil;
25880
+ }
25881
+
25882
+
25883
+ /*
25884
+ Document-method: GPS_PVT::GPS::RINEX_Clock.clock_error
25885
+
25886
+ call-seq:
25887
+ clock_error(int const & sat_id, Time t) -> double
25888
+
25889
+ An instance method.
25890
+
25891
+ */
25892
+ SWIGINTERN VALUE
25893
+ _wrap_RINEX_Clock_clock_error(int argc, VALUE *argv, VALUE self) {
25894
+ RINEX_Clock< double > *arg1 = (RINEX_Clock< double > *) 0 ;
25895
+ int *arg2 = 0 ;
25896
+ GPS_Time< double > *arg3 = 0 ;
25897
+ void *argp1 = 0 ;
25898
+ int res1 = 0 ;
25899
+ int temp2 ;
25900
+ int val2 ;
25901
+ int ecode2 = 0 ;
25902
+ void *argp3 ;
25903
+ int res3 = 0 ;
25904
+ double result;
25905
+ VALUE vresult = Qnil;
25906
+
25907
+ if ((argc < 2) || (argc > 2)) {
25908
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
25909
+ }
25910
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RINEX_ClockT_double_t, 0 | 0 );
25911
+ if (!SWIG_IsOK(res1)) {
25912
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "RINEX_Clock< double > const *","clock_error", 1, self ));
25913
+ }
25914
+ arg1 = reinterpret_cast< RINEX_Clock< double > * >(argp1);
25915
+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
25916
+ if (!SWIG_IsOK(ecode2)) {
25917
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","clock_error", 2, argv[0] ));
25918
+ }
25919
+ temp2 = static_cast< int >(val2);
25920
+ arg2 = &temp2;
25921
+ res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
25922
+ if (!SWIG_IsOK(res3)) {
25923
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "GPS_Time< double > const &","clock_error", 3, argv[1] ));
25924
+ }
25925
+ if (!argp3) {
25926
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","clock_error", 3, argv[1]));
25927
+ }
25928
+ arg3 = reinterpret_cast< GPS_Time< double > * >(argp3);
25929
+ {
25930
+ try {
25931
+ result = (double)((RINEX_Clock< double > const *)arg1)->clock_error((int const &)*arg2,(GPS_Time< double > const &)*arg3);
25932
+ } catch (const native_exception &e) {
25933
+ e.regenerate();
25934
+ SWIG_fail;
25935
+ } catch (const std::exception& e) {
25936
+ SWIG_exception_fail(SWIG_RuntimeError, e.what());
25937
+ }
25938
+ }
25939
+ vresult = SWIG_From_double(static_cast< double >(result));
25940
+ return vresult;
25941
+ fail:
25942
+ return Qnil;
25943
+ }
25944
+
25945
+
25946
+ /*
25947
+ Document-method: GPS_PVT::GPS::RINEX_Clock.clock_error_dot
25948
+
25949
+ call-seq:
25950
+ clock_error_dot(int const & sat_id, Time t) -> double
25951
+
25952
+ An instance method.
25953
+
25954
+ */
25955
+ SWIGINTERN VALUE
25956
+ _wrap_RINEX_Clock_clock_error_dot(int argc, VALUE *argv, VALUE self) {
25957
+ RINEX_Clock< double > *arg1 = (RINEX_Clock< double > *) 0 ;
25958
+ int *arg2 = 0 ;
25959
+ GPS_Time< double > *arg3 = 0 ;
25960
+ void *argp1 = 0 ;
25961
+ int res1 = 0 ;
25962
+ int temp2 ;
25963
+ int val2 ;
25964
+ int ecode2 = 0 ;
25965
+ void *argp3 ;
25966
+ int res3 = 0 ;
25967
+ double result;
25968
+ VALUE vresult = Qnil;
25969
+
25970
+ if ((argc < 2) || (argc > 2)) {
25971
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
25972
+ }
25973
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RINEX_ClockT_double_t, 0 | 0 );
25974
+ if (!SWIG_IsOK(res1)) {
25975
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "RINEX_Clock< double > const *","clock_error_dot", 1, self ));
25976
+ }
25977
+ arg1 = reinterpret_cast< RINEX_Clock< double > * >(argp1);
25978
+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
25979
+ if (!SWIG_IsOK(ecode2)) {
25980
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","clock_error_dot", 2, argv[0] ));
25981
+ }
25982
+ temp2 = static_cast< int >(val2);
25983
+ arg2 = &temp2;
25984
+ res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
25985
+ if (!SWIG_IsOK(res3)) {
25986
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "GPS_Time< double > const &","clock_error_dot", 3, argv[1] ));
25987
+ }
25988
+ if (!argp3) {
25989
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","clock_error_dot", 3, argv[1]));
25990
+ }
25991
+ arg3 = reinterpret_cast< GPS_Time< double > * >(argp3);
25992
+ {
25993
+ try {
25994
+ result = (double)((RINEX_Clock< double > const *)arg1)->clock_error_dot((int const &)*arg2,(GPS_Time< double > const &)*arg3);
25995
+ } catch (const native_exception &e) {
25996
+ e.regenerate();
25997
+ SWIG_fail;
25998
+ } catch (const std::exception& e) {
25999
+ SWIG_exception_fail(SWIG_RuntimeError, e.what());
26000
+ }
26001
+ }
26002
+ vresult = SWIG_From_double(static_cast< double >(result));
25464
26003
  return vresult;
25465
26004
  fail:
25466
26005
  return Qnil;
@@ -25469,12 +26008,12 @@ fail:
25469
26008
 
25470
26009
  SWIGINTERN VALUE
25471
26010
  #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
25472
- _wrap_SP3_allocate(VALUE self)
26011
+ _wrap_RINEX_Clock_allocate(VALUE self)
25473
26012
  #else
25474
- _wrap_SP3_allocate(int argc, VALUE *argv, VALUE self)
26013
+ _wrap_RINEX_Clock_allocate(int argc, VALUE *argv, VALUE self)
25475
26014
  #endif
25476
26015
  {
25477
- VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_SP3T_double_t);
26016
+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_RINEX_ClockT_double_t);
25478
26017
  #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
25479
26018
  rb_obj_call_init(vresult, argc, argv);
25480
26019
  #endif
@@ -25483,24 +26022,24 @@ _wrap_SP3_allocate(int argc, VALUE *argv, VALUE self)
25483
26022
 
25484
26023
 
25485
26024
  /*
25486
- Document-method: GPS_PVT::GPS::SP3.new
26025
+ Document-method: GPS_PVT::GPS::RINEX_Clock.new
25487
26026
 
25488
26027
  call-seq:
25489
- SP3.new
26028
+ RINEX_Clock.new
25490
26029
 
25491
26030
  Class constructor.
25492
26031
 
25493
26032
  */
25494
26033
  SWIGINTERN VALUE
25495
- _wrap_new_SP3(int argc, VALUE *argv, VALUE self) {
25496
- SP3< double > *result = 0 ;
26034
+ _wrap_new_RINEX_Clock(int argc, VALUE *argv, VALUE self) {
26035
+ RINEX_Clock< double > *result = 0 ;
25497
26036
 
25498
26037
  if ((argc < 0) || (argc > 0)) {
25499
26038
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
25500
26039
  }
25501
26040
  {
25502
26041
  try {
25503
- result = (SP3< double > *)new SP3< double >();
26042
+ result = (RINEX_Clock< double > *)new RINEX_Clock< double >();
25504
26043
  DATA_PTR(self) = result;
25505
26044
  } catch (const native_exception &e) {
25506
26045
  e.regenerate();
@@ -25516,8 +26055,8 @@ fail:
25516
26055
 
25517
26056
 
25518
26057
  SWIGINTERN void
25519
- free_SP3_Sl_double_Sg_(void *self) {
25520
- SP3< double > *arg1 = (SP3< double > *)self;
26058
+ free_RINEX_Clock_Sl_double_Sg_(void *self) {
26059
+ RINEX_Clock< double > *arg1 = (RINEX_Clock< double > *)self;
25521
26060
  delete arg1;
25522
26061
  }
25523
26062
 
@@ -25545,6 +26084,12 @@ static void *_p_SBAS_EphemerisT_double_tTo_p_SBAS_SpaceNodeT_double_t__Satellite
25545
26084
  static void *_p_GPS_Ionospheric_UTC_ParametersT_double_tTo_p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters(void *x, int *SWIGUNUSEDPARM(newmemory)) {
25546
26085
  return (void *)((GPS_SpaceNode< double >::Ionospheric_UTC_Parameters *) ((GPS_Ionospheric_UTC_Parameters< double > *) x));
25547
26086
  }
26087
+ static void *_p_SP3T_double_tTo_p_PushableData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26088
+ return (void *)((PushableData *) ((SP3< double > *) x));
26089
+ }
26090
+ static void *_p_RINEX_ClockT_double_tTo_p_PushableData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26091
+ return (void *)((PushableData *) ((RINEX_Clock< double > *) x));
26092
+ }
25548
26093
  static void *_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_tTo_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
25549
26094
  return (void *)((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > *) ((Matrix< double,Array2D_Dense< double > > *) x));
25550
26095
  }
@@ -25576,6 +26121,8 @@ static swig_type_info _swigt__p_MatrixT_double_Array2D_DenseT_double_t_MatrixVie
25576
26121
  static swig_type_info _swigt__p_MatrixViewBaseT_t = {"_p_MatrixViewBaseT_t", "MatrixViewBase< > *|MatViewBase *", 0, 0, (void*)0, 0};
25577
26122
  static swig_type_info _swigt__p_MatrixViewFilterT_MatrixViewBaseT_t_t = {"_p_MatrixViewFilterT_MatrixViewBaseT_t_t", "MatrixViewFilter< MatrixViewBase< > > *|MatView_f *", 0, 0, (void*)0, 0};
25578
26123
  static swig_type_info _swigt__p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t = {"_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t", "Matrix_Frozen< double,Array2D_Dense< double > > *|Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > *", 0, 0, (void*)0, 0};
26124
+ static swig_type_info _swigt__p_PushableData = {"_p_PushableData", "PushableData *", 0, 0, (void*)0, 0};
26125
+ static swig_type_info _swigt__p_RINEX_ClockT_double_t = {"_p_RINEX_ClockT_double_t", "RINEX_Clock< double > *", 0, 0, (void*)0, 0};
25579
26126
  static swig_type_info _swigt__p_RINEX_ObservationT_double_t = {"_p_RINEX_ObservationT_double_t", "RINEX_Observation< double > *", 0, 0, (void*)0, 0};
25580
26127
  static swig_type_info _swigt__p_SBAS_EphemerisT_double_t = {"_p_SBAS_EphemerisT_double_t", "SBAS_Ephemeris< double > *", 0, 0, (void*)0, 0};
25581
26128
  static swig_type_info _swigt__p_SBAS_SolverOptionsT_double_t = {"_p_SBAS_SolverOptionsT_double_t", "SBAS_SolverOptions< double > *", 0, 0, (void*)0, 0};
@@ -25598,6 +26145,7 @@ static swig_type_info _swigt__p_int_t = {"_p_int_t", "int_t *", 0, 0, (void*)0,
25598
26145
  static swig_type_info _swigt__p_llh_t = {"_p_llh_t", "llh_t *", 0, 0, (void*)0, 0};
25599
26146
  static swig_type_info _swigt__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t = {"_p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t", "GPS_User_PVT< double >::base_t::detection_t **|GPS_Solver_RAIM_LSR< double,GPS_Solver_Base_Debug< double,GPS_Solver_Base< double > > >::user_pvt_t::detection_t **", 0, 0, (void*)0, 0};
25600
26147
  static swig_type_info _swigt__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t = {"_p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t", "GPS_User_PVT< double >::base_t::exclusion_t **|GPS_Solver_RAIM_LSR< double,GPS_Solver_Base_Debug< double,GPS_Solver_Base< double > > >::user_pvt_t::exclusion_t **", 0, 0, (void*)0, 0};
26148
+ static swig_type_info _swigt__p_p_double = {"_p_p_double", "double **", 0, 0, (void*)0, 0};
25601
26149
  static swig_type_info _swigt__p_range_correction_list_t = {"_p_range_correction_list_t", "range_correction_list_t *", 0, 0, (void*)0, 0};
25602
26150
  static swig_type_info _swigt__p_s16_t = {"_p_s16_t", "s16_t *", 0, 0, (void*)0, 0};
25603
26151
  static swig_type_info _swigt__p_s32_t = {"_p_s32_t", "s32_t *", 0, 0, (void*)0, 0};
@@ -25605,6 +26153,7 @@ static swig_type_info _swigt__p_s8_t = {"_p_s8_t", "s8_t *", 0, 0, (void*)0, 0};
25605
26153
  static swig_type_info _swigt__p_satellites_t = {"_p_satellites_t", "satellites_t *", 0, 0, (void*)0, 0};
25606
26154
  static swig_type_info _swigt__p_self_t = {"_p_self_t", "self_t *", 0, 0, (void*)0, 0};
25607
26155
  static swig_type_info _swigt__p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t = {"_p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t", "SBAS_SpaceNode< double >::available_satellites_t *|std::vector< std::pair< int,SBAS_SpaceNode< double >::Satellite const * > > *", 0, 0, (void*)0, 0};
26156
+ static swig_type_info _swigt__p_super_t = {"_p_super_t", "super_t *", 0, 0, (void*)0, 0};
25608
26157
  static swig_type_info _swigt__p_swig__GC_VALUE = {"_p_swig__GC_VALUE", "swig::GC_VALUE *", 0, 0, (void*)0, 0};
25609
26158
  static swig_type_info _swigt__p_u16_t = {"_p_u16_t", "u16_t *", 0, 0, (void*)0, 0};
25610
26159
  static swig_type_info _swigt__p_u32_t = {"_p_u32_t", "u32_t *", 0, 0, (void*)0, 0};
@@ -25641,6 +26190,8 @@ static swig_type_info *swig_type_initial[] = {
25641
26190
  &_swigt__p_MatrixViewBaseT_t,
25642
26191
  &_swigt__p_MatrixViewFilterT_MatrixViewBaseT_t_t,
25643
26192
  &_swigt__p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t,
26193
+ &_swigt__p_PushableData,
26194
+ &_swigt__p_RINEX_ClockT_double_t,
25644
26195
  &_swigt__p_RINEX_ObservationT_double_t,
25645
26196
  &_swigt__p_SBAS_EphemerisT_double_t,
25646
26197
  &_swigt__p_SBAS_SolverOptionsT_double_t,
@@ -25663,6 +26214,7 @@ static swig_type_info *swig_type_initial[] = {
25663
26214
  &_swigt__p_llh_t,
25664
26215
  &_swigt__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t,
25665
26216
  &_swigt__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t,
26217
+ &_swigt__p_p_double,
25666
26218
  &_swigt__p_range_correction_list_t,
25667
26219
  &_swigt__p_s16_t,
25668
26220
  &_swigt__p_s32_t,
@@ -25670,6 +26222,7 @@ static swig_type_info *swig_type_initial[] = {
25670
26222
  &_swigt__p_satellites_t,
25671
26223
  &_swigt__p_self_t,
25672
26224
  &_swigt__p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t,
26225
+ &_swigt__p_super_t,
25673
26226
  &_swigt__p_swig__GC_VALUE,
25674
26227
  &_swigt__p_u16_t,
25675
26228
  &_swigt__p_u32_t,
@@ -25706,6 +26259,8 @@ static swig_cast_info _swigc__p_MatrixT_double_Array2D_DenseT_double_t_MatrixVie
25706
26259
  static swig_cast_info _swigc__p_MatrixViewBaseT_t[] = { {&_swigt__p_MatrixViewBaseT_t, 0, 0, 0},{0, 0, 0, 0}};
25707
26260
  static swig_cast_info _swigc__p_MatrixViewFilterT_MatrixViewBaseT_t_t[] = { {&_swigt__p_MatrixViewFilterT_MatrixViewBaseT_t_t, 0, 0, 0},{0, 0, 0, 0}};
25708
26261
  static swig_cast_info _swigc__p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t[] = { {&_swigt__p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0, 0, 0}, {&_swigt__p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, _p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_tTo_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0, 0},{0, 0, 0, 0}};
26262
+ static swig_cast_info _swigc__p_PushableData[] = { {&_swigt__p_SP3T_double_t, _p_SP3T_double_tTo_p_PushableData, 0, 0}, {&_swigt__p_RINEX_ClockT_double_t, _p_RINEX_ClockT_double_tTo_p_PushableData, 0, 0}, {&_swigt__p_PushableData, 0, 0, 0},{0, 0, 0, 0}};
26263
+ static swig_cast_info _swigc__p_RINEX_ClockT_double_t[] = { {&_swigt__p_RINEX_ClockT_double_t, 0, 0, 0},{0, 0, 0, 0}};
25709
26264
  static swig_cast_info _swigc__p_RINEX_ObservationT_double_t[] = { {&_swigt__p_RINEX_ObservationT_double_t, 0, 0, 0},{0, 0, 0, 0}};
25710
26265
  static swig_cast_info _swigc__p_SBAS_EphemerisT_double_t[] = { {&_swigt__p_SBAS_EphemerisT_double_t, 0, 0, 0},{0, 0, 0, 0}};
25711
26266
  static swig_cast_info _swigc__p_SBAS_SolverOptionsT_double_t[] = { {&_swigt__p_SBAS_SolverOptionsT_double_t, 0, 0, 0},{0, 0, 0, 0}};
@@ -25728,6 +26283,7 @@ static swig_cast_info _swigc__p_int_t[] = { {&_swigt__p_int_t, 0, 0, 0},{0, 0,
25728
26283
  static swig_cast_info _swigc__p_llh_t[] = { {&_swigt__p_llh_t, 0, 0, 0},{0, 0, 0, 0}};
25729
26284
  static swig_cast_info _swigc__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t[] = { {&_swigt__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t, 0, 0, 0},{0, 0, 0, 0}};
25730
26285
  static swig_cast_info _swigc__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t[] = { {&_swigt__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t, 0, 0, 0},{0, 0, 0, 0}};
26286
+ static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
25731
26287
  static swig_cast_info _swigc__p_range_correction_list_t[] = { {&_swigt__p_range_correction_list_t, 0, 0, 0},{0, 0, 0, 0}};
25732
26288
  static swig_cast_info _swigc__p_s16_t[] = { {&_swigt__p_s16_t, 0, 0, 0},{0, 0, 0, 0}};
25733
26289
  static swig_cast_info _swigc__p_s32_t[] = { {&_swigt__p_s32_t, 0, 0, 0},{0, 0, 0, 0}};
@@ -25735,6 +26291,7 @@ static swig_cast_info _swigc__p_s8_t[] = { {&_swigt__p_s8_t, 0, 0, 0},{0, 0, 0,
25735
26291
  static swig_cast_info _swigc__p_satellites_t[] = { {&_swigt__p_satellites_t, 0, 0, 0},{0, 0, 0, 0}};
25736
26292
  static swig_cast_info _swigc__p_self_t[] = { {&_swigt__p_self_t, 0, 0, 0},{0, 0, 0, 0}};
25737
26293
  static swig_cast_info _swigc__p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t[] = { {&_swigt__p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
26294
+ static swig_cast_info _swigc__p_super_t[] = { {&_swigt__p_super_t, 0, 0, 0},{0, 0, 0, 0}};
25738
26295
  static swig_cast_info _swigc__p_swig__GC_VALUE[] = { {&_swigt__p_swig__GC_VALUE, 0, 0, 0},{0, 0, 0, 0}};
25739
26296
  static swig_cast_info _swigc__p_u16_t[] = { {&_swigt__p_u16_t, 0, 0, 0},{0, 0, 0, 0}};
25740
26297
  static swig_cast_info _swigc__p_u32_t[] = { {&_swigt__p_u32_t, 0, 0, 0},{0, 0, 0, 0}};
@@ -25771,6 +26328,8 @@ static swig_cast_info *swig_cast_initial[] = {
25771
26328
  _swigc__p_MatrixViewBaseT_t,
25772
26329
  _swigc__p_MatrixViewFilterT_MatrixViewBaseT_t_t,
25773
26330
  _swigc__p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t,
26331
+ _swigc__p_PushableData,
26332
+ _swigc__p_RINEX_ClockT_double_t,
25774
26333
  _swigc__p_RINEX_ObservationT_double_t,
25775
26334
  _swigc__p_SBAS_EphemerisT_double_t,
25776
26335
  _swigc__p_SBAS_SolverOptionsT_double_t,
@@ -25793,6 +26352,7 @@ static swig_cast_info *swig_cast_initial[] = {
25793
26352
  _swigc__p_llh_t,
25794
26353
  _swigc__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t,
25795
26354
  _swigc__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t,
26355
+ _swigc__p_p_double,
25796
26356
  _swigc__p_range_correction_list_t,
25797
26357
  _swigc__p_s16_t,
25798
26358
  _swigc__p_s32_t,
@@ -25800,6 +26360,7 @@ static swig_cast_info *swig_cast_initial[] = {
25800
26360
  _swigc__p_satellites_t,
25801
26361
  _swigc__p_self_t,
25802
26362
  _swigc__p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t,
26363
+ _swigc__p_super_t,
25803
26364
  _swigc__p_swig__GC_VALUE,
25804
26365
  _swigc__p_u16_t,
25805
26366
  _swigc__p_u32_t,
@@ -26076,6 +26637,21 @@ SWIGEXPORT void Init_GPS(void) {
26076
26637
  rb_require("gps_pvt/Coordinate");
26077
26638
  rb_define_const(mGPS, "GPS_SC2RAD", SWIG_From_double(static_cast< double >(3.1415926535898)));
26078
26639
 
26640
+ SwigClassPushableData.klass = rb_define_class_under(mGPS, "PushableData", rb_cObject);
26641
+ SWIG_TypeClientData(SWIGTYPE_p_PushableData, (void *) &SwigClassPushableData);
26642
+ rb_define_alloc_func(SwigClassPushableData.klass, _wrap_PushableData_allocate);
26643
+ rb_define_method(SwigClassPushableData.klass, "initialize", VALUEFUNC(_wrap_new_PushableData), -1);
26644
+ rb_define_const(SwigClassPushableData.klass, "SYS_GPS", SWIG_From_int(static_cast< int >(PushableData::SYS_GPS)));
26645
+ rb_define_const(SwigClassPushableData.klass, "SYS_SBAS", SWIG_From_int(static_cast< int >(PushableData::SYS_SBAS)));
26646
+ rb_define_const(SwigClassPushableData.klass, "SYS_QZSS", SWIG_From_int(static_cast< int >(PushableData::SYS_QZSS)));
26647
+ rb_define_const(SwigClassPushableData.klass, "SYS_GLONASS", SWIG_From_int(static_cast< int >(PushableData::SYS_GLONASS)));
26648
+ rb_define_const(SwigClassPushableData.klass, "SYS_GALILEO", SWIG_From_int(static_cast< int >(PushableData::SYS_GALILEO)));
26649
+ rb_define_const(SwigClassPushableData.klass, "SYS_BEIDOU", SWIG_From_int(static_cast< int >(PushableData::SYS_BEIDOU)));
26650
+ rb_define_const(SwigClassPushableData.klass, "SYS_SYSTEMS", SWIG_From_int(static_cast< int >(PushableData::SYS_SYSTEMS)));
26651
+ SwigClassPushableData.mark = 0;
26652
+ SwigClassPushableData.destroy = (void (*)(void *)) free_PushableData;
26653
+ SwigClassPushableData.trackObjects = 0;
26654
+
26079
26655
  SwigClassTime.klass = rb_define_class_under(mGPS, "Time", rb_cObject);
26080
26656
  SWIG_TypeClientData(SWIGTYPE_p_GPS_TimeT_double_t, (void *) &SwigClassTime);
26081
26657
  rb_define_alloc_func(SwigClassTime.klass, _wrap_Time_allocate);
@@ -26568,27 +27144,33 @@ SWIGEXPORT void Init_GPS(void) {
26568
27144
  SwigClassRINEX_Observation.destroy = (void (*)(void *)) free_RINEX_Observation_Sl_double_Sg_;
26569
27145
  SwigClassRINEX_Observation.trackObjects = 0;
26570
27146
 
26571
- SwigClassSP3.klass = rb_define_class_under(mGPS, "SP3", rb_cObject);
27147
+ SwigClassSP3.klass = rb_define_class_under(mGPS, "SP3", ((swig_class *) SWIGTYPE_p_PushableData->clientdata)->klass);
26572
27148
  SWIG_TypeClientData(SWIGTYPE_p_SP3T_double_t, (void *) &SwigClassSP3);
26573
27149
  rb_define_alloc_func(SwigClassSP3.klass, _wrap_SP3_allocate);
26574
27150
  rb_define_method(SwigClassSP3.klass, "initialize", VALUEFUNC(_wrap_new_SP3), -1);
26575
27151
  rb_define_method(SwigClassSP3.klass, "read", VALUEFUNC(_wrap_SP3_read), -1);
26576
- rb_define_const(SwigClassSP3.klass, "SYS_GPS", SWIG_From_int(static_cast< int >(SP3< double >::SYS_GPS)));
26577
- rb_define_const(SwigClassSP3.klass, "SYS_SBAS", SWIG_From_int(static_cast< int >(SP3< double >::SYS_SBAS)));
26578
- rb_define_const(SwigClassSP3.klass, "SYS_QZSS", SWIG_From_int(static_cast< int >(SP3< double >::SYS_QZSS)));
26579
- rb_define_const(SwigClassSP3.klass, "SYS_GLONASS", SWIG_From_int(static_cast< int >(SP3< double >::SYS_GLONASS)));
26580
- rb_define_const(SwigClassSP3.klass, "SYS_GALILEO", SWIG_From_int(static_cast< int >(SP3< double >::SYS_GALILEO)));
26581
- rb_define_const(SwigClassSP3.klass, "SYS_BEIDOU", SWIG_From_int(static_cast< int >(SP3< double >::SYS_BEIDOU)));
26582
- rb_define_const(SwigClassSP3.klass, "SYS_SYSTEMS", SWIG_From_int(static_cast< int >(SP3< double >::SYS_SYSTEMS)));
27152
+ rb_define_method(SwigClassSP3.klass, "satellites", VALUEFUNC(_wrap_SP3_satellites), -1);
26583
27153
  rb_define_method(SwigClassSP3.klass, "push", VALUEFUNC(_wrap_SP3_push), -1);
26584
27154
  rb_define_method(SwigClassSP3.klass, "position", VALUEFUNC(_wrap_SP3_position), -1);
26585
27155
  rb_define_method(SwigClassSP3.klass, "velocity", VALUEFUNC(_wrap_SP3_velocity), -1);
26586
27156
  rb_define_method(SwigClassSP3.klass, "clock_error", VALUEFUNC(_wrap_SP3_clock_error), -1);
26587
27157
  rb_define_method(SwigClassSP3.klass, "clock_error_dot", VALUEFUNC(_wrap_SP3_clock_error_dot), -1);
26588
27158
  rb_define_method(SwigClassSP3.klass, "apply_antex", VALUEFUNC(_wrap_SP3_apply_antex), -1);
26589
- rb_define_method(SwigClassSP3.klass, "satellites", VALUEFUNC(_wrap_SP3_satellites), -1);
26590
27159
  SwigClassSP3.mark = 0;
26591
27160
  SwigClassSP3.destroy = (void (*)(void *)) free_SP3_Sl_double_Sg_;
26592
27161
  SwigClassSP3.trackObjects = 0;
27162
+
27163
+ SwigClassRINEX_Clock.klass = rb_define_class_under(mGPS, "RINEX_Clock", ((swig_class *) SWIGTYPE_p_PushableData->clientdata)->klass);
27164
+ SWIG_TypeClientData(SWIGTYPE_p_RINEX_ClockT_double_t, (void *) &SwigClassRINEX_Clock);
27165
+ rb_define_alloc_func(SwigClassRINEX_Clock.klass, _wrap_RINEX_Clock_allocate);
27166
+ rb_define_method(SwigClassRINEX_Clock.klass, "initialize", VALUEFUNC(_wrap_new_RINEX_Clock), -1);
27167
+ rb_define_method(SwigClassRINEX_Clock.klass, "read", VALUEFUNC(_wrap_RINEX_Clock_read), -1);
27168
+ rb_define_method(SwigClassRINEX_Clock.klass, "satellites", VALUEFUNC(_wrap_RINEX_Clock_satellites), -1);
27169
+ rb_define_method(SwigClassRINEX_Clock.klass, "push", VALUEFUNC(_wrap_RINEX_Clock_push), -1);
27170
+ rb_define_method(SwigClassRINEX_Clock.klass, "clock_error", VALUEFUNC(_wrap_RINEX_Clock_clock_error), -1);
27171
+ rb_define_method(SwigClassRINEX_Clock.klass, "clock_error_dot", VALUEFUNC(_wrap_RINEX_Clock_clock_error_dot), -1);
27172
+ SwigClassRINEX_Clock.mark = 0;
27173
+ SwigClassRINEX_Clock.destroy = (void (*)(void *)) free_RINEX_Clock_Sl_double_Sg_;
27174
+ SwigClassRINEX_Clock.trackObjects = 0;
26593
27175
  }
26594
27176