gps_pvt 0.6.1 → 0.6.2

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.
@@ -2361,6 +2361,10 @@ struct GPS_Ephemeris : public GPS_SpaceNode<FloatT>::SatelliteProperties::Epheme
2361
2361
  GPS_Ephemeris(const typename GPS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris &eph)
2362
2362
  : GPS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris(eph),
2363
2363
  iode_subframe3(eph.iode) {}
2364
+ struct constellation_res_t {
2365
+ System_XYZ<FloatT, WGS84> position, velocity;
2366
+ FloatT clock_error, clock_error_dot;
2367
+ };
2364
2368
  };
2365
2369
 
2366
2370
 
@@ -3737,11 +3741,12 @@ SWIGINTERN void GPS_Ephemeris_Sl_double_Sg__parse(GPS_Ephemeris< double > *self,
3737
3741
  break;
3738
3742
  }
3739
3743
  }
3740
- SWIGINTERN void GPS_Ephemeris_Sl_double_Sg__constellation__SWIG_0(GPS_Ephemeris< double > const *self,System_XYZ< double,WGS84 > &position,System_XYZ< double,WGS84 > &velocity,GPS_Time< double > const &t,double const &pseudo_range=0,bool const &with_velocity=true){
3741
- typename GPS_SpaceNode<double>::SatelliteProperties::constellation_t res(
3742
- self->constellation(t, pseudo_range, with_velocity));
3743
- position = res.position;
3744
- velocity = res.velocity;
3744
+ 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){
3745
+ typename GPS_SpaceNode<double>::SatelliteProperties::constellation_t pv(
3746
+ self->constellation(t_tx, dt_transit, true));
3747
+ typename GPS_Ephemeris<double>::constellation_res_t res = {
3748
+ pv.position, pv.velocity, self->clock_error(t_tx), self->clock_error_dot(t_tx)};
3749
+ return res;
3745
3750
  }
3746
3751
 
3747
3752
  namespace swig {
@@ -4211,11 +4216,12 @@ SWIGINTERN double SBAS_Ephemeris_Sl_double_Sg__set_a_Gf1(SBAS_Ephemeris< double
4211
4216
  SWIGINTERN double const &SBAS_Ephemeris_Sl_double_Sg__get_a_Gf1(SBAS_Ephemeris< double > const *self){
4212
4217
  return self->a_Gf1;
4213
4218
  }
4214
- SWIGINTERN void SBAS_Ephemeris_Sl_double_Sg__constellation__SWIG_0(SBAS_Ephemeris< double > const *self,System_XYZ< double,WGS84 > &position,System_XYZ< double,WGS84 > &velocity,GPS_Time< double > const &t,double const &pseudo_range=0,bool const &with_velocity=true){
4215
- typename SBAS_SpaceNode<double>::SatelliteProperties::constellation_t res(
4216
- self->constellation(t, pseudo_range, with_velocity));
4217
- position = res.position;
4218
- velocity = res.velocity;
4219
+ 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){
4220
+ typename SBAS_SpaceNode<double>::SatelliteProperties::constellation_t pv(
4221
+ self->constellation(t_tx, dt_transit, with_velocity));
4222
+ typename GPS_Ephemeris<double>::constellation_res_t res = {
4223
+ pv.position, pv.velocity, self->clock_error(t_tx), self->clock_error_dot(t_tx)};
4224
+ return res;
4219
4225
  }
4220
4226
  SWIGINTERN void SBAS_SpaceNode_Sl_double_Sg__register_ephemeris__SWIG_0(SBAS_SpaceNode< double > *self,int const &prn,SBAS_Ephemeris< double > const &eph,int const &priority_delta=1){
4221
4227
  self->satellite(prn).register_ephemeris(eph, priority_delta);
@@ -4473,14 +4479,12 @@ SWIGINTERN bool GLONASS_Ephemeris_Sl_double_Sg__parse__SWIG_0(GLONASS_Ephemeris<
4473
4479
  self->has_string = has_string;
4474
4480
  return updated;
4475
4481
  }
4476
- SWIGINTERN double GLONASS_Ephemeris_Sl_double_Sg__clock_error__SWIG_0(GLONASS_Ephemeris< double > const *self,GPS_Time< double > const &t_arrival,double const &pseudo_range=0){
4477
- return self->clock_error(t_arrival, pseudo_range);
4478
- }
4479
- SWIGINTERN void GLONASS_Ephemeris_Sl_double_Sg__constellation__SWIG_0(GLONASS_Ephemeris< double > const *self,System_XYZ< double,WGS84 > &position,System_XYZ< double,WGS84 > &velocity,GPS_Time< double > const &t,double const &pseudo_range=0){
4480
- typename GPS_SpaceNode<double>::SatelliteProperties::constellation_t res(
4481
- self->constellation(t, pseudo_range));
4482
- position = res.position;
4483
- velocity = res.velocity;
4482
+ 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){
4483
+ typename GPS_SpaceNode<double>::SatelliteProperties::constellation_t pv(
4484
+ self->constellation(t_tx, dt_transit));
4485
+ typename GPS_Ephemeris<double>::constellation_res_t res = {
4486
+ pv.position, pv.velocity, self->clock_error(t_tx), self->clock_error_dot()};
4487
+ return res;
4484
4488
  }
4485
4489
  SWIGINTERN bool GLONASS_Ephemeris_Sl_double_Sg__is_in_range(GLONASS_Ephemeris< double > const *self,GPS_Time< double > const &t){
4486
4490
  // "invalidate()" is used to make raw and converted data inconsistent.
@@ -13744,9 +13748,8 @@ fail:
13744
13748
  Document-method: GPS_PVT::GPS::Ephemeris.constellation
13745
13749
 
13746
13750
  call-seq:
13747
- constellation(Time t, double const & pseudo_range=0, bool const & with_velocity=True)
13748
- constellation(Time t, double const & pseudo_range=0)
13749
- constellation(Time t)
13751
+ constellation(Time t_tx, double const & dt_transit=0) -> GPS_Ephemeris< double >::constellation_res_t
13752
+ constellation(Time t_tx) -> GPS_Ephemeris< double >::constellation_res_t
13750
13753
 
13751
13754
  An instance method.
13752
13755
 
@@ -13754,106 +13757,18 @@ An instance method.
13754
13757
  SWIGINTERN VALUE
13755
13758
  _wrap_Ephemeris_constellation__SWIG_0(int argc, VALUE *argv, VALUE self) {
13756
13759
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
13757
- System_XYZ< double,WGS84 > *arg2 = 0 ;
13758
- System_XYZ< double,WGS84 > *arg3 = 0 ;
13759
- GPS_Time< double > *arg4 = 0 ;
13760
- double *arg5 = 0 ;
13761
- bool *arg6 = 0 ;
13762
- void *argp1 = 0 ;
13763
- int res1 = 0 ;
13764
- System_XYZ< double,WGS84 > temp2 ;
13765
- System_XYZ< double,WGS84 > temp3 ;
13766
- void *argp4 ;
13767
- int res4 = 0 ;
13768
- double temp5 ;
13769
- double val5 ;
13770
- int ecode5 = 0 ;
13771
- bool temp6 ;
13772
- bool val6 ;
13773
- int ecode6 = 0 ;
13774
- VALUE vresult = Qnil;
13775
-
13776
-
13777
- arg2 = &temp2;
13778
-
13779
-
13780
- arg3 = &temp3;
13781
-
13782
- if ((argc < 3) || (argc > 3)) {
13783
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
13784
- }
13785
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_EphemerisT_double_t, 0 | 0 );
13786
- if (!SWIG_IsOK(res1)) {
13787
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","constellation", 1, self ));
13788
- }
13789
- arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
13790
- res4 = SWIG_ConvertPtr(argv[0], &argp4, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
13791
- if (!SWIG_IsOK(res4)) {
13792
- SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "GPS_Time< double > const &","constellation", 4, argv[0] ));
13793
- }
13794
- if (!argp4) {
13795
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","constellation", 4, argv[0]));
13796
- }
13797
- arg4 = reinterpret_cast< GPS_Time< double > * >(argp4);
13798
- ecode5 = SWIG_AsVal_double(argv[1], &val5);
13799
- if (!SWIG_IsOK(ecode5)) {
13800
- SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","constellation", 5, argv[1] ));
13801
- }
13802
- temp5 = static_cast< double >(val5);
13803
- arg5 = &temp5;
13804
- ecode6 = SWIG_AsVal_bool(argv[2], &val6);
13805
- if (!SWIG_IsOK(ecode6)) {
13806
- SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","constellation", 6, argv[2] ));
13807
- }
13808
- temp6 = static_cast< bool >(val6);
13809
- arg6 = &temp6;
13810
- {
13811
- try {
13812
- GPS_Ephemeris_Sl_double_Sg__constellation__SWIG_0((GPS_Ephemeris< double > const *)arg1,*arg2,*arg3,(GPS_Time< double > const &)*arg4,(double const &)*arg5,(bool const &)*arg6);
13813
- } catch (const native_exception &e) {
13814
- e.regenerate();
13815
- SWIG_fail;
13816
- } catch (const std::exception& e) {
13817
- SWIG_exception_fail(SWIG_RuntimeError, e.what());
13818
- }
13819
- }
13820
- vresult = rb_ary_new();
13821
- {
13822
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ< double,WGS84 >(*arg2)), SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN));
13823
- }
13824
- {
13825
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ< double,WGS84 >(*arg3)), SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN));
13826
- }
13827
- return vresult;
13828
- fail:
13829
- return Qnil;
13830
- }
13831
-
13832
-
13833
- SWIGINTERN VALUE
13834
- _wrap_Ephemeris_constellation__SWIG_1(int argc, VALUE *argv, VALUE self) {
13835
- GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
13836
- System_XYZ< double,WGS84 > *arg2 = 0 ;
13837
- System_XYZ< double,WGS84 > *arg3 = 0 ;
13838
- GPS_Time< double > *arg4 = 0 ;
13839
- double *arg5 = 0 ;
13760
+ GPS_Time< double > *arg2 = 0 ;
13761
+ double *arg3 = 0 ;
13840
13762
  void *argp1 = 0 ;
13841
13763
  int res1 = 0 ;
13842
- System_XYZ< double,WGS84 > temp2 ;
13843
- System_XYZ< double,WGS84 > temp3 ;
13844
- void *argp4 ;
13845
- int res4 = 0 ;
13846
- double temp5 ;
13847
- double val5 ;
13848
- int ecode5 = 0 ;
13764
+ void *argp2 ;
13765
+ int res2 = 0 ;
13766
+ double temp3 ;
13767
+ double val3 ;
13768
+ int ecode3 = 0 ;
13769
+ GPS_Ephemeris< double >::constellation_res_t result;
13849
13770
  VALUE vresult = Qnil;
13850
13771
 
13851
-
13852
- arg2 = &temp2;
13853
-
13854
-
13855
- arg3 = &temp3;
13856
-
13857
13772
  if ((argc < 2) || (argc > 2)) {
13858
13773
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
13859
13774
  }
@@ -13862,23 +13777,23 @@ _wrap_Ephemeris_constellation__SWIG_1(int argc, VALUE *argv, VALUE self) {
13862
13777
  SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","constellation", 1, self ));
13863
13778
  }
13864
13779
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
13865
- res4 = SWIG_ConvertPtr(argv[0], &argp4, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
13866
- if (!SWIG_IsOK(res4)) {
13867
- SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "GPS_Time< double > const &","constellation", 4, argv[0] ));
13780
+ res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
13781
+ if (!SWIG_IsOK(res2)) {
13782
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_Time< double > const &","constellation", 2, argv[0] ));
13868
13783
  }
13869
- if (!argp4) {
13870
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","constellation", 4, argv[0]));
13784
+ if (!argp2) {
13785
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","constellation", 2, argv[0]));
13871
13786
  }
13872
- arg4 = reinterpret_cast< GPS_Time< double > * >(argp4);
13873
- ecode5 = SWIG_AsVal_double(argv[1], &val5);
13874
- if (!SWIG_IsOK(ecode5)) {
13875
- SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","constellation", 5, argv[1] ));
13787
+ arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
13788
+ ecode3 = SWIG_AsVal_double(argv[1], &val3);
13789
+ if (!SWIG_IsOK(ecode3)) {
13790
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","constellation", 3, argv[1] ));
13876
13791
  }
13877
- temp5 = static_cast< double >(val5);
13878
- arg5 = &temp5;
13792
+ temp3 = static_cast< double >(val3);
13793
+ arg3 = &temp3;
13879
13794
  {
13880
13795
  try {
13881
- GPS_Ephemeris_Sl_double_Sg__constellation__SWIG_0((GPS_Ephemeris< double > const *)arg1,*arg2,*arg3,(GPS_Time< double > const &)*arg4,(double const &)*arg5);
13796
+ result = GPS_Ephemeris_Sl_double_Sg__constellation__SWIG_0((GPS_Ephemeris< double > const *)arg1,(GPS_Time< double > const &)*arg2,(double const &)*arg3);
13882
13797
  } catch (const native_exception &e) {
13883
13798
  e.regenerate();
13884
13799
  SWIG_fail;
@@ -13886,12 +13801,17 @@ _wrap_Ephemeris_constellation__SWIG_1(int argc, VALUE *argv, VALUE self) {
13886
13801
  SWIG_exception_fail(SWIG_RuntimeError, e.what());
13887
13802
  }
13888
13803
  }
13889
- vresult = rb_ary_new();
13890
- {
13891
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ< double,WGS84 >(*arg2)), SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN));
13892
- }
13893
13804
  {
13894
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ< double,WGS84 >(*arg3)), SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN));
13805
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ<double, WGS84>((&result)->position)),
13806
+ SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN))
13807
+
13808
+ ;
13809
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ<double, WGS84>((&result)->velocity)),
13810
+ SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN))
13811
+
13812
+ ;
13813
+ vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((&result)->clock_error));
13814
+ vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((&result)->clock_error_dot));
13895
13815
  }
13896
13816
  return vresult;
13897
13817
  fail:
@@ -13900,25 +13820,16 @@ fail:
13900
13820
 
13901
13821
 
13902
13822
  SWIGINTERN VALUE
13903
- _wrap_Ephemeris_constellation__SWIG_2(int argc, VALUE *argv, VALUE self) {
13823
+ _wrap_Ephemeris_constellation__SWIG_1(int argc, VALUE *argv, VALUE self) {
13904
13824
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
13905
- System_XYZ< double,WGS84 > *arg2 = 0 ;
13906
- System_XYZ< double,WGS84 > *arg3 = 0 ;
13907
- GPS_Time< double > *arg4 = 0 ;
13825
+ GPS_Time< double > *arg2 = 0 ;
13908
13826
  void *argp1 = 0 ;
13909
13827
  int res1 = 0 ;
13910
- System_XYZ< double,WGS84 > temp2 ;
13911
- System_XYZ< double,WGS84 > temp3 ;
13912
- void *argp4 ;
13913
- int res4 = 0 ;
13828
+ void *argp2 ;
13829
+ int res2 = 0 ;
13830
+ GPS_Ephemeris< double >::constellation_res_t result;
13914
13831
  VALUE vresult = Qnil;
13915
13832
 
13916
-
13917
- arg2 = &temp2;
13918
-
13919
-
13920
- arg3 = &temp3;
13921
-
13922
13833
  if ((argc < 1) || (argc > 1)) {
13923
13834
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13924
13835
  }
@@ -13927,17 +13838,17 @@ _wrap_Ephemeris_constellation__SWIG_2(int argc, VALUE *argv, VALUE self) {
13927
13838
  SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","constellation", 1, self ));
13928
13839
  }
13929
13840
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
13930
- res4 = SWIG_ConvertPtr(argv[0], &argp4, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
13931
- if (!SWIG_IsOK(res4)) {
13932
- SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "GPS_Time< double > const &","constellation", 4, argv[0] ));
13841
+ res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
13842
+ if (!SWIG_IsOK(res2)) {
13843
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_Time< double > const &","constellation", 2, argv[0] ));
13933
13844
  }
13934
- if (!argp4) {
13935
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","constellation", 4, argv[0]));
13845
+ if (!argp2) {
13846
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","constellation", 2, argv[0]));
13936
13847
  }
13937
- arg4 = reinterpret_cast< GPS_Time< double > * >(argp4);
13848
+ arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
13938
13849
  {
13939
13850
  try {
13940
- GPS_Ephemeris_Sl_double_Sg__constellation__SWIG_0((GPS_Ephemeris< double > const *)arg1,*arg2,*arg3,(GPS_Time< double > const &)*arg4);
13851
+ result = GPS_Ephemeris_Sl_double_Sg__constellation__SWIG_0((GPS_Ephemeris< double > const *)arg1,(GPS_Time< double > const &)*arg2);
13941
13852
  } catch (const native_exception &e) {
13942
13853
  e.regenerate();
13943
13854
  SWIG_fail;
@@ -13945,12 +13856,17 @@ _wrap_Ephemeris_constellation__SWIG_2(int argc, VALUE *argv, VALUE self) {
13945
13856
  SWIG_exception_fail(SWIG_RuntimeError, e.what());
13946
13857
  }
13947
13858
  }
13948
- vresult = rb_ary_new();
13949
- {
13950
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ< double,WGS84 >(*arg2)), SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN));
13951
- }
13952
13859
  {
13953
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ< double,WGS84 >(*arg3)), SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN));
13860
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ<double, WGS84>((&result)->position)),
13861
+ SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN))
13862
+
13863
+ ;
13864
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ<double, WGS84>((&result)->velocity)),
13865
+ SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN))
13866
+
13867
+ ;
13868
+ vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((&result)->clock_error));
13869
+ vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((&result)->clock_error_dot));
13954
13870
  }
13955
13871
  return vresult;
13956
13872
  fail:
@@ -13960,12 +13876,12 @@ fail:
13960
13876
 
13961
13877
  SWIGINTERN VALUE _wrap_Ephemeris_constellation(int nargs, VALUE *args, VALUE self) {
13962
13878
  int argc;
13963
- VALUE argv[5];
13879
+ VALUE argv[4];
13964
13880
  int ii;
13965
13881
 
13966
13882
  argc = nargs + 1;
13967
13883
  argv[0] = self;
13968
- if (argc > 5) SWIG_fail;
13884
+ if (argc > 4) SWIG_fail;
13969
13885
  for (ii = 1; (ii < argc); ++ii) {
13970
13886
  argv[ii] = args[ii-1];
13971
13887
  }
@@ -13979,7 +13895,7 @@ SWIGINTERN VALUE _wrap_Ephemeris_constellation(int nargs, VALUE *args, VALUE sel
13979
13895
  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_NO_NULL);
13980
13896
  _v = SWIG_CheckState(res);
13981
13897
  if (_v) {
13982
- return _wrap_Ephemeris_constellation__SWIG_2(nargs, args, self);
13898
+ return _wrap_Ephemeris_constellation__SWIG_1(nargs, args, self);
13983
13899
  }
13984
13900
  }
13985
13901
  }
@@ -13998,43 +13914,16 @@ SWIGINTERN VALUE _wrap_Ephemeris_constellation(int nargs, VALUE *args, VALUE sel
13998
13914
  _v = SWIG_CheckState(res);
13999
13915
  }
14000
13916
  if (_v) {
14001
- return _wrap_Ephemeris_constellation__SWIG_1(nargs, args, self);
14002
- }
14003
- }
14004
- }
14005
- }
14006
- if (argc == 4) {
14007
- int _v;
14008
- void *vptr = 0;
14009
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_EphemerisT_double_t, 0);
14010
- _v = SWIG_CheckState(res);
14011
- if (_v) {
14012
- void *vptr = 0;
14013
- int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_NO_NULL);
14014
- _v = SWIG_CheckState(res);
14015
- if (_v) {
14016
- {
14017
- int res = SWIG_AsVal_double(argv[2], NULL);
14018
- _v = SWIG_CheckState(res);
14019
- }
14020
- if (_v) {
14021
- {
14022
- int res = SWIG_AsVal_bool(argv[3], NULL);
14023
- _v = SWIG_CheckState(res);
14024
- }
14025
- if (_v) {
14026
- return _wrap_Ephemeris_constellation__SWIG_0(nargs, args, self);
14027
- }
13917
+ return _wrap_Ephemeris_constellation__SWIG_0(nargs, args, self);
14028
13918
  }
14029
13919
  }
14030
13920
  }
14031
13921
  }
14032
13922
 
14033
13923
  fail:
14034
- Ruby_Format_OverloadedError( argc, 5, "constellation",
14035
- " void constellation(System_XYZ< double,WGS84 > &position, System_XYZ< double,WGS84 > &velocity, GPS_Time< double > const &t, double const &pseudo_range, bool const &with_velocity)\n"
14036
- " void constellation(System_XYZ< double,WGS84 > &position, System_XYZ< double,WGS84 > &velocity, GPS_Time< double > const &t, double const &pseudo_range)\n"
14037
- " void constellation(System_XYZ< double,WGS84 > &position, System_XYZ< double,WGS84 > &velocity, GPS_Time< double > const &t)\n");
13924
+ Ruby_Format_OverloadedError( argc, 4, "constellation",
13925
+ " GPS_Ephemeris< double >::constellation_res_t constellation(GPS_Time< double > const &t_tx, double const &dt_transit)\n"
13926
+ " GPS_Ephemeris< double >::constellation_res_t constellation(GPS_Time< double > const &t_tx)\n");
14038
13927
 
14039
13928
  return Qnil;
14040
13929
  }
@@ -18735,9 +18624,9 @@ fail:
18735
18624
  Document-method: GPS_PVT::GPS::Ephemeris_SBAS.constellation
18736
18625
 
18737
18626
  call-seq:
18738
- constellation(Time t, double const & pseudo_range=0, bool const & with_velocity=True)
18739
- constellation(Time t, double const & pseudo_range=0)
18740
- constellation(Time t)
18627
+ constellation(Time t_tx, double const & dt_transit=0, bool const & with_velocity=True) -> GPS_Ephemeris< double >::constellation_res_t
18628
+ constellation(Time t_tx, double const & dt_transit=0) -> GPS_Ephemeris< double >::constellation_res_t
18629
+ constellation(Time t_tx) -> GPS_Ephemeris< double >::constellation_res_t
18741
18630
 
18742
18631
  An instance method.
18743
18632
 
@@ -18745,31 +18634,22 @@ An instance method.
18745
18634
  SWIGINTERN VALUE
18746
18635
  _wrap_Ephemeris_SBAS_constellation__SWIG_0(int argc, VALUE *argv, VALUE self) {
18747
18636
  SBAS_Ephemeris< double > *arg1 = (SBAS_Ephemeris< double > *) 0 ;
18748
- System_XYZ< double,WGS84 > *arg2 = 0 ;
18749
- System_XYZ< double,WGS84 > *arg3 = 0 ;
18750
- GPS_Time< double > *arg4 = 0 ;
18751
- double *arg5 = 0 ;
18752
- bool *arg6 = 0 ;
18637
+ GPS_Time< double > *arg2 = 0 ;
18638
+ double *arg3 = 0 ;
18639
+ bool *arg4 = 0 ;
18753
18640
  void *argp1 = 0 ;
18754
18641
  int res1 = 0 ;
18755
- System_XYZ< double,WGS84 > temp2 ;
18756
- System_XYZ< double,WGS84 > temp3 ;
18757
- void *argp4 ;
18758
- int res4 = 0 ;
18759
- double temp5 ;
18760
- double val5 ;
18761
- int ecode5 = 0 ;
18762
- bool temp6 ;
18763
- bool val6 ;
18764
- int ecode6 = 0 ;
18642
+ void *argp2 ;
18643
+ int res2 = 0 ;
18644
+ double temp3 ;
18645
+ double val3 ;
18646
+ int ecode3 = 0 ;
18647
+ bool temp4 ;
18648
+ bool val4 ;
18649
+ int ecode4 = 0 ;
18650
+ GPS_Ephemeris< double >::constellation_res_t result;
18765
18651
  VALUE vresult = Qnil;
18766
18652
 
18767
-
18768
- arg2 = &temp2;
18769
-
18770
-
18771
- arg3 = &temp3;
18772
-
18773
18653
  if ((argc < 3) || (argc > 3)) {
18774
18654
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
18775
18655
  }
@@ -18778,29 +18658,29 @@ _wrap_Ephemeris_SBAS_constellation__SWIG_0(int argc, VALUE *argv, VALUE self) {
18778
18658
  SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_Ephemeris< double > const *","constellation", 1, self ));
18779
18659
  }
18780
18660
  arg1 = reinterpret_cast< SBAS_Ephemeris< double > * >(argp1);
18781
- res4 = SWIG_ConvertPtr(argv[0], &argp4, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
18782
- if (!SWIG_IsOK(res4)) {
18783
- SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "GPS_Time< double > const &","constellation", 4, argv[0] ));
18661
+ res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
18662
+ if (!SWIG_IsOK(res2)) {
18663
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_Time< double > const &","constellation", 2, argv[0] ));
18784
18664
  }
18785
- if (!argp4) {
18786
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","constellation", 4, argv[0]));
18665
+ if (!argp2) {
18666
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","constellation", 2, argv[0]));
18787
18667
  }
18788
- arg4 = reinterpret_cast< GPS_Time< double > * >(argp4);
18789
- ecode5 = SWIG_AsVal_double(argv[1], &val5);
18790
- if (!SWIG_IsOK(ecode5)) {
18791
- SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","constellation", 5, argv[1] ));
18668
+ arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
18669
+ ecode3 = SWIG_AsVal_double(argv[1], &val3);
18670
+ if (!SWIG_IsOK(ecode3)) {
18671
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","constellation", 3, argv[1] ));
18792
18672
  }
18793
- temp5 = static_cast< double >(val5);
18794
- arg5 = &temp5;
18795
- ecode6 = SWIG_AsVal_bool(argv[2], &val6);
18796
- if (!SWIG_IsOK(ecode6)) {
18797
- SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","constellation", 6, argv[2] ));
18673
+ temp3 = static_cast< double >(val3);
18674
+ arg3 = &temp3;
18675
+ ecode4 = SWIG_AsVal_bool(argv[2], &val4);
18676
+ if (!SWIG_IsOK(ecode4)) {
18677
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","constellation", 4, argv[2] ));
18798
18678
  }
18799
- temp6 = static_cast< bool >(val6);
18800
- arg6 = &temp6;
18679
+ temp4 = static_cast< bool >(val4);
18680
+ arg4 = &temp4;
18801
18681
  {
18802
18682
  try {
18803
- SBAS_Ephemeris_Sl_double_Sg__constellation__SWIG_0((SBAS_Ephemeris< double > const *)arg1,*arg2,*arg3,(GPS_Time< double > const &)*arg4,(double const &)*arg5,(bool const &)*arg6);
18683
+ result = SBAS_Ephemeris_Sl_double_Sg__constellation__SWIG_0((SBAS_Ephemeris< double > const *)arg1,(GPS_Time< double > const &)*arg2,(double const &)*arg3,(bool const &)*arg4);
18804
18684
  } catch (const native_exception &e) {
18805
18685
  e.regenerate();
18806
18686
  SWIG_fail;
@@ -18808,12 +18688,17 @@ _wrap_Ephemeris_SBAS_constellation__SWIG_0(int argc, VALUE *argv, VALUE self) {
18808
18688
  SWIG_exception_fail(SWIG_RuntimeError, e.what());
18809
18689
  }
18810
18690
  }
18811
- vresult = rb_ary_new();
18812
- {
18813
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ< double,WGS84 >(*arg2)), SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN));
18814
- }
18815
18691
  {
18816
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ< double,WGS84 >(*arg3)), SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN));
18692
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ<double, WGS84>((&result)->position)),
18693
+ SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN))
18694
+
18695
+ ;
18696
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ<double, WGS84>((&result)->velocity)),
18697
+ SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN))
18698
+
18699
+ ;
18700
+ vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((&result)->clock_error));
18701
+ vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((&result)->clock_error_dot));
18817
18702
  }
18818
18703
  return vresult;
18819
18704
  fail:
@@ -18824,27 +18709,18 @@ fail:
18824
18709
  SWIGINTERN VALUE
18825
18710
  _wrap_Ephemeris_SBAS_constellation__SWIG_1(int argc, VALUE *argv, VALUE self) {
18826
18711
  SBAS_Ephemeris< double > *arg1 = (SBAS_Ephemeris< double > *) 0 ;
18827
- System_XYZ< double,WGS84 > *arg2 = 0 ;
18828
- System_XYZ< double,WGS84 > *arg3 = 0 ;
18829
- GPS_Time< double > *arg4 = 0 ;
18830
- double *arg5 = 0 ;
18712
+ GPS_Time< double > *arg2 = 0 ;
18713
+ double *arg3 = 0 ;
18831
18714
  void *argp1 = 0 ;
18832
18715
  int res1 = 0 ;
18833
- System_XYZ< double,WGS84 > temp2 ;
18834
- System_XYZ< double,WGS84 > temp3 ;
18835
- void *argp4 ;
18836
- int res4 = 0 ;
18837
- double temp5 ;
18838
- double val5 ;
18839
- int ecode5 = 0 ;
18716
+ void *argp2 ;
18717
+ int res2 = 0 ;
18718
+ double temp3 ;
18719
+ double val3 ;
18720
+ int ecode3 = 0 ;
18721
+ GPS_Ephemeris< double >::constellation_res_t result;
18840
18722
  VALUE vresult = Qnil;
18841
18723
 
18842
-
18843
- arg2 = &temp2;
18844
-
18845
-
18846
- arg3 = &temp3;
18847
-
18848
18724
  if ((argc < 2) || (argc > 2)) {
18849
18725
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
18850
18726
  }
@@ -18853,23 +18729,23 @@ _wrap_Ephemeris_SBAS_constellation__SWIG_1(int argc, VALUE *argv, VALUE self) {
18853
18729
  SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_Ephemeris< double > const *","constellation", 1, self ));
18854
18730
  }
18855
18731
  arg1 = reinterpret_cast< SBAS_Ephemeris< double > * >(argp1);
18856
- res4 = SWIG_ConvertPtr(argv[0], &argp4, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
18857
- if (!SWIG_IsOK(res4)) {
18858
- SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "GPS_Time< double > const &","constellation", 4, argv[0] ));
18732
+ res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
18733
+ if (!SWIG_IsOK(res2)) {
18734
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_Time< double > const &","constellation", 2, argv[0] ));
18859
18735
  }
18860
- if (!argp4) {
18861
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","constellation", 4, argv[0]));
18736
+ if (!argp2) {
18737
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","constellation", 2, argv[0]));
18862
18738
  }
18863
- arg4 = reinterpret_cast< GPS_Time< double > * >(argp4);
18864
- ecode5 = SWIG_AsVal_double(argv[1], &val5);
18865
- if (!SWIG_IsOK(ecode5)) {
18866
- SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","constellation", 5, argv[1] ));
18739
+ arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
18740
+ ecode3 = SWIG_AsVal_double(argv[1], &val3);
18741
+ if (!SWIG_IsOK(ecode3)) {
18742
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","constellation", 3, argv[1] ));
18867
18743
  }
18868
- temp5 = static_cast< double >(val5);
18869
- arg5 = &temp5;
18744
+ temp3 = static_cast< double >(val3);
18745
+ arg3 = &temp3;
18870
18746
  {
18871
18747
  try {
18872
- SBAS_Ephemeris_Sl_double_Sg__constellation__SWIG_0((SBAS_Ephemeris< double > const *)arg1,*arg2,*arg3,(GPS_Time< double > const &)*arg4,(double const &)*arg5);
18748
+ result = SBAS_Ephemeris_Sl_double_Sg__constellation__SWIG_0((SBAS_Ephemeris< double > const *)arg1,(GPS_Time< double > const &)*arg2,(double const &)*arg3);
18873
18749
  } catch (const native_exception &e) {
18874
18750
  e.regenerate();
18875
18751
  SWIG_fail;
@@ -18877,12 +18753,17 @@ _wrap_Ephemeris_SBAS_constellation__SWIG_1(int argc, VALUE *argv, VALUE self) {
18877
18753
  SWIG_exception_fail(SWIG_RuntimeError, e.what());
18878
18754
  }
18879
18755
  }
18880
- vresult = rb_ary_new();
18881
18756
  {
18882
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ< double,WGS84 >(*arg2)), SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN));
18883
- }
18884
- {
18885
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ< double,WGS84 >(*arg3)), SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN));
18757
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ<double, WGS84>((&result)->position)),
18758
+ SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN))
18759
+
18760
+ ;
18761
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ<double, WGS84>((&result)->velocity)),
18762
+ SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN))
18763
+
18764
+ ;
18765
+ vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((&result)->clock_error));
18766
+ vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((&result)->clock_error_dot));
18886
18767
  }
18887
18768
  return vresult;
18888
18769
  fail:
@@ -18893,23 +18774,14 @@ fail:
18893
18774
  SWIGINTERN VALUE
18894
18775
  _wrap_Ephemeris_SBAS_constellation__SWIG_2(int argc, VALUE *argv, VALUE self) {
18895
18776
  SBAS_Ephemeris< double > *arg1 = (SBAS_Ephemeris< double > *) 0 ;
18896
- System_XYZ< double,WGS84 > *arg2 = 0 ;
18897
- System_XYZ< double,WGS84 > *arg3 = 0 ;
18898
- GPS_Time< double > *arg4 = 0 ;
18777
+ GPS_Time< double > *arg2 = 0 ;
18899
18778
  void *argp1 = 0 ;
18900
18779
  int res1 = 0 ;
18901
- System_XYZ< double,WGS84 > temp2 ;
18902
- System_XYZ< double,WGS84 > temp3 ;
18903
- void *argp4 ;
18904
- int res4 = 0 ;
18780
+ void *argp2 ;
18781
+ int res2 = 0 ;
18782
+ GPS_Ephemeris< double >::constellation_res_t result;
18905
18783
  VALUE vresult = Qnil;
18906
18784
 
18907
-
18908
- arg2 = &temp2;
18909
-
18910
-
18911
- arg3 = &temp3;
18912
-
18913
18785
  if ((argc < 1) || (argc > 1)) {
18914
18786
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
18915
18787
  }
@@ -18918,17 +18790,17 @@ _wrap_Ephemeris_SBAS_constellation__SWIG_2(int argc, VALUE *argv, VALUE self) {
18918
18790
  SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_Ephemeris< double > const *","constellation", 1, self ));
18919
18791
  }
18920
18792
  arg1 = reinterpret_cast< SBAS_Ephemeris< double > * >(argp1);
18921
- res4 = SWIG_ConvertPtr(argv[0], &argp4, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
18922
- if (!SWIG_IsOK(res4)) {
18923
- SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "GPS_Time< double > const &","constellation", 4, argv[0] ));
18793
+ res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
18794
+ if (!SWIG_IsOK(res2)) {
18795
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_Time< double > const &","constellation", 2, argv[0] ));
18924
18796
  }
18925
- if (!argp4) {
18926
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","constellation", 4, argv[0]));
18797
+ if (!argp2) {
18798
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","constellation", 2, argv[0]));
18927
18799
  }
18928
- arg4 = reinterpret_cast< GPS_Time< double > * >(argp4);
18800
+ arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
18929
18801
  {
18930
18802
  try {
18931
- SBAS_Ephemeris_Sl_double_Sg__constellation__SWIG_0((SBAS_Ephemeris< double > const *)arg1,*arg2,*arg3,(GPS_Time< double > const &)*arg4);
18803
+ result = SBAS_Ephemeris_Sl_double_Sg__constellation__SWIG_0((SBAS_Ephemeris< double > const *)arg1,(GPS_Time< double > const &)*arg2);
18932
18804
  } catch (const native_exception &e) {
18933
18805
  e.regenerate();
18934
18806
  SWIG_fail;
@@ -18936,12 +18808,17 @@ _wrap_Ephemeris_SBAS_constellation__SWIG_2(int argc, VALUE *argv, VALUE self) {
18936
18808
  SWIG_exception_fail(SWIG_RuntimeError, e.what());
18937
18809
  }
18938
18810
  }
18939
- vresult = rb_ary_new();
18940
- {
18941
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ< double,WGS84 >(*arg2)), SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN));
18942
- }
18943
18811
  {
18944
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ< double,WGS84 >(*arg3)), SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN));
18812
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ<double, WGS84>((&result)->position)),
18813
+ SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN))
18814
+
18815
+ ;
18816
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ<double, WGS84>((&result)->velocity)),
18817
+ SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN))
18818
+
18819
+ ;
18820
+ vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((&result)->clock_error));
18821
+ vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((&result)->clock_error_dot));
18945
18822
  }
18946
18823
  return vresult;
18947
18824
  fail:
@@ -19023,9 +18900,9 @@ SWIGINTERN VALUE _wrap_Ephemeris_SBAS_constellation(int nargs, VALUE *args, VALU
19023
18900
 
19024
18901
  fail:
19025
18902
  Ruby_Format_OverloadedError( argc, 5, "constellation",
19026
- " void constellation(System_XYZ< double,WGS84 > &position, System_XYZ< double,WGS84 > &velocity, GPS_Time< double > const &t, double const &pseudo_range, bool const &with_velocity)\n"
19027
- " void constellation(System_XYZ< double,WGS84 > &position, System_XYZ< double,WGS84 > &velocity, GPS_Time< double > const &t, double const &pseudo_range)\n"
19028
- " void constellation(System_XYZ< double,WGS84 > &position, System_XYZ< double,WGS84 > &velocity, GPS_Time< double > const &t)\n");
18903
+ " GPS_Ephemeris< double >::constellation_res_t constellation(GPS_Time< double > const &t_tx, double const &dt_transit, bool const &with_velocity)\n"
18904
+ " GPS_Ephemeris< double >::constellation_res_t constellation(GPS_Time< double > const &t_tx, double const &dt_transit)\n"
18905
+ " GPS_Ephemeris< double >::constellation_res_t constellation(GPS_Time< double > const &t_tx)\n");
19029
18906
 
19030
18907
  return Qnil;
19031
18908
  }
@@ -24385,17 +24262,17 @@ fail:
24385
24262
 
24386
24263
 
24387
24264
  /*
24388
- Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.clock_error
24265
+ Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.constellation
24389
24266
 
24390
24267
  call-seq:
24391
- clock_error(Time t_arrival, double const & pseudo_range=0) -> double
24392
- clock_error(Time t_arrival) -> double
24268
+ constellation(Time t_tx, double const & dt_transit=0) -> GPS_Ephemeris< double >::constellation_res_t
24269
+ constellation(Time t_tx) -> GPS_Ephemeris< double >::constellation_res_t
24393
24270
 
24394
24271
  An instance method.
24395
24272
 
24396
24273
  */
24397
24274
  SWIGINTERN VALUE
24398
- _wrap_Ephemeris_GLONASS_clock_error__SWIG_0(int argc, VALUE *argv, VALUE self) {
24275
+ _wrap_Ephemeris_GLONASS_constellation__SWIG_0(int argc, VALUE *argv, VALUE self) {
24399
24276
  GLONASS_Ephemeris< double > *arg1 = (GLONASS_Ephemeris< double > *) 0 ;
24400
24277
  GPS_Time< double > *arg2 = 0 ;
24401
24278
  double *arg3 = 0 ;
@@ -24406,7 +24283,7 @@ _wrap_Ephemeris_GLONASS_clock_error__SWIG_0(int argc, VALUE *argv, VALUE self) {
24406
24283
  double temp3 ;
24407
24284
  double val3 ;
24408
24285
  int ecode3 = 0 ;
24409
- double result;
24286
+ GPS_Ephemeris< double >::constellation_res_t result;
24410
24287
  VALUE vresult = Qnil;
24411
24288
 
24412
24289
  if ((argc < 2) || (argc > 2)) {
@@ -24414,26 +24291,26 @@ _wrap_Ephemeris_GLONASS_clock_error__SWIG_0(int argc, VALUE *argv, VALUE self) {
24414
24291
  }
24415
24292
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLONASS_EphemerisT_double_t, 0 | 0 );
24416
24293
  if (!SWIG_IsOK(res1)) {
24417
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GLONASS_Ephemeris< double > const *","clock_error", 1, self ));
24294
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GLONASS_Ephemeris< double > const *","constellation", 1, self ));
24418
24295
  }
24419
24296
  arg1 = reinterpret_cast< GLONASS_Ephemeris< double > * >(argp1);
24420
24297
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
24421
24298
  if (!SWIG_IsOK(res2)) {
24422
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_Time< double > const &","clock_error", 2, argv[0] ));
24299
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_Time< double > const &","constellation", 2, argv[0] ));
24423
24300
  }
24424
24301
  if (!argp2) {
24425
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","clock_error", 2, argv[0]));
24302
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","constellation", 2, argv[0]));
24426
24303
  }
24427
24304
  arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
24428
24305
  ecode3 = SWIG_AsVal_double(argv[1], &val3);
24429
24306
  if (!SWIG_IsOK(ecode3)) {
24430
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","clock_error", 3, argv[1] ));
24307
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","constellation", 3, argv[1] ));
24431
24308
  }
24432
24309
  temp3 = static_cast< double >(val3);
24433
24310
  arg3 = &temp3;
24434
24311
  {
24435
24312
  try {
24436
- result = (double)GLONASS_Ephemeris_Sl_double_Sg__clock_error__SWIG_0((GLONASS_Ephemeris< double > const *)arg1,(GPS_Time< double > const &)*arg2,(double const &)*arg3);
24313
+ result = GLONASS_Ephemeris_Sl_double_Sg__constellation__SWIG_0((GLONASS_Ephemeris< double > const *)arg1,(GPS_Time< double > const &)*arg2,(double const &)*arg3);
24437
24314
  } catch (const native_exception &e) {
24438
24315
  e.regenerate();
24439
24316
  SWIG_fail;
@@ -24441,7 +24318,18 @@ _wrap_Ephemeris_GLONASS_clock_error__SWIG_0(int argc, VALUE *argv, VALUE self) {
24441
24318
  SWIG_exception_fail(SWIG_RuntimeError, e.what());
24442
24319
  }
24443
24320
  }
24444
- vresult = SWIG_From_double(static_cast< double >(result));
24321
+ {
24322
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ<double, WGS84>((&result)->position)),
24323
+ SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN))
24324
+
24325
+ ;
24326
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ<double, WGS84>((&result)->velocity)),
24327
+ SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN))
24328
+
24329
+ ;
24330
+ vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((&result)->clock_error));
24331
+ vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((&result)->clock_error_dot));
24332
+ }
24445
24333
  return vresult;
24446
24334
  fail:
24447
24335
  return Qnil;
@@ -24449,14 +24337,14 @@ fail:
24449
24337
 
24450
24338
 
24451
24339
  SWIGINTERN VALUE
24452
- _wrap_Ephemeris_GLONASS_clock_error__SWIG_1(int argc, VALUE *argv, VALUE self) {
24340
+ _wrap_Ephemeris_GLONASS_constellation__SWIG_1(int argc, VALUE *argv, VALUE self) {
24453
24341
  GLONASS_Ephemeris< double > *arg1 = (GLONASS_Ephemeris< double > *) 0 ;
24454
24342
  GPS_Time< double > *arg2 = 0 ;
24455
24343
  void *argp1 = 0 ;
24456
24344
  int res1 = 0 ;
24457
24345
  void *argp2 ;
24458
24346
  int res2 = 0 ;
24459
- double result;
24347
+ GPS_Ephemeris< double >::constellation_res_t result;
24460
24348
  VALUE vresult = Qnil;
24461
24349
 
24462
24350
  if ((argc < 1) || (argc > 1)) {
@@ -24464,20 +24352,20 @@ _wrap_Ephemeris_GLONASS_clock_error__SWIG_1(int argc, VALUE *argv, VALUE self) {
24464
24352
  }
24465
24353
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLONASS_EphemerisT_double_t, 0 | 0 );
24466
24354
  if (!SWIG_IsOK(res1)) {
24467
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GLONASS_Ephemeris< double > const *","clock_error", 1, self ));
24355
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GLONASS_Ephemeris< double > const *","constellation", 1, self ));
24468
24356
  }
24469
24357
  arg1 = reinterpret_cast< GLONASS_Ephemeris< double > * >(argp1);
24470
24358
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
24471
24359
  if (!SWIG_IsOK(res2)) {
24472
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_Time< double > const &","clock_error", 2, argv[0] ));
24360
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_Time< double > const &","constellation", 2, argv[0] ));
24473
24361
  }
24474
24362
  if (!argp2) {
24475
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","clock_error", 2, argv[0]));
24363
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","constellation", 2, argv[0]));
24476
24364
  }
24477
24365
  arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
24478
24366
  {
24479
24367
  try {
24480
- result = (double)GLONASS_Ephemeris_Sl_double_Sg__clock_error__SWIG_0((GLONASS_Ephemeris< double > const *)arg1,(GPS_Time< double > const &)*arg2);
24368
+ result = GLONASS_Ephemeris_Sl_double_Sg__constellation__SWIG_0((GLONASS_Ephemeris< double > const *)arg1,(GPS_Time< double > const &)*arg2);
24481
24369
  } catch (const native_exception &e) {
24482
24370
  e.regenerate();
24483
24371
  SWIG_fail;
@@ -24485,199 +24373,17 @@ _wrap_Ephemeris_GLONASS_clock_error__SWIG_1(int argc, VALUE *argv, VALUE self) {
24485
24373
  SWIG_exception_fail(SWIG_RuntimeError, e.what());
24486
24374
  }
24487
24375
  }
24488
- vresult = SWIG_From_double(static_cast< double >(result));
24489
- return vresult;
24490
- fail:
24491
- return Qnil;
24492
- }
24493
-
24494
-
24495
- SWIGINTERN VALUE _wrap_Ephemeris_GLONASS_clock_error(int nargs, VALUE *args, VALUE self) {
24496
- int argc;
24497
- VALUE argv[4];
24498
- int ii;
24499
-
24500
- argc = nargs + 1;
24501
- argv[0] = self;
24502
- if (argc > 4) SWIG_fail;
24503
- for (ii = 1; (ii < argc); ++ii) {
24504
- argv[ii] = args[ii-1];
24505
- }
24506
- if (argc == 2) {
24507
- int _v;
24508
- void *vptr = 0;
24509
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GLONASS_EphemerisT_double_t, 0);
24510
- _v = SWIG_CheckState(res);
24511
- if (_v) {
24512
- void *vptr = 0;
24513
- int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_NO_NULL);
24514
- _v = SWIG_CheckState(res);
24515
- if (_v) {
24516
- return _wrap_Ephemeris_GLONASS_clock_error__SWIG_1(nargs, args, self);
24517
- }
24518
- }
24519
- }
24520
- if (argc == 3) {
24521
- int _v;
24522
- void *vptr = 0;
24523
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GLONASS_EphemerisT_double_t, 0);
24524
- _v = SWIG_CheckState(res);
24525
- if (_v) {
24526
- void *vptr = 0;
24527
- int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_NO_NULL);
24528
- _v = SWIG_CheckState(res);
24529
- if (_v) {
24530
- {
24531
- int res = SWIG_AsVal_double(argv[2], NULL);
24532
- _v = SWIG_CheckState(res);
24533
- }
24534
- if (_v) {
24535
- return _wrap_Ephemeris_GLONASS_clock_error__SWIG_0(nargs, args, self);
24536
- }
24537
- }
24538
- }
24539
- }
24540
-
24541
- fail:
24542
- Ruby_Format_OverloadedError( argc, 4, "clock_error",
24543
- " double clock_error(GPS_Time< double > const &t_arrival, double const &pseudo_range)\n"
24544
- " double clock_error(GPS_Time< double > const &t_arrival)\n");
24545
-
24546
- return Qnil;
24547
- }
24548
-
24549
-
24550
- /*
24551
- Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.constellation
24552
-
24553
- call-seq:
24554
- constellation(Time t, double const & pseudo_range=0)
24555
- constellation(Time t)
24556
-
24557
- An instance method.
24558
-
24559
- */
24560
- SWIGINTERN VALUE
24561
- _wrap_Ephemeris_GLONASS_constellation__SWIG_0(int argc, VALUE *argv, VALUE self) {
24562
- GLONASS_Ephemeris< double > *arg1 = (GLONASS_Ephemeris< double > *) 0 ;
24563
- System_XYZ< double,WGS84 > *arg2 = 0 ;
24564
- System_XYZ< double,WGS84 > *arg3 = 0 ;
24565
- GPS_Time< double > *arg4 = 0 ;
24566
- double *arg5 = 0 ;
24567
- void *argp1 = 0 ;
24568
- int res1 = 0 ;
24569
- System_XYZ< double,WGS84 > temp2 ;
24570
- System_XYZ< double,WGS84 > temp3 ;
24571
- void *argp4 ;
24572
- int res4 = 0 ;
24573
- double temp5 ;
24574
- double val5 ;
24575
- int ecode5 = 0 ;
24576
- VALUE vresult = Qnil;
24577
-
24578
-
24579
- arg2 = &temp2;
24580
-
24581
-
24582
- arg3 = &temp3;
24583
-
24584
- if ((argc < 2) || (argc > 2)) {
24585
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
24586
- }
24587
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLONASS_EphemerisT_double_t, 0 | 0 );
24588
- if (!SWIG_IsOK(res1)) {
24589
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GLONASS_Ephemeris< double > const *","constellation", 1, self ));
24590
- }
24591
- arg1 = reinterpret_cast< GLONASS_Ephemeris< double > * >(argp1);
24592
- res4 = SWIG_ConvertPtr(argv[0], &argp4, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
24593
- if (!SWIG_IsOK(res4)) {
24594
- SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "GPS_Time< double > const &","constellation", 4, argv[0] ));
24595
- }
24596
- if (!argp4) {
24597
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","constellation", 4, argv[0]));
24598
- }
24599
- arg4 = reinterpret_cast< GPS_Time< double > * >(argp4);
24600
- ecode5 = SWIG_AsVal_double(argv[1], &val5);
24601
- if (!SWIG_IsOK(ecode5)) {
24602
- SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","constellation", 5, argv[1] ));
24603
- }
24604
- temp5 = static_cast< double >(val5);
24605
- arg5 = &temp5;
24606
24376
  {
24607
- try {
24608
- GLONASS_Ephemeris_Sl_double_Sg__constellation__SWIG_0((GLONASS_Ephemeris< double > const *)arg1,*arg2,*arg3,(GPS_Time< double > const &)*arg4,(double const &)*arg5);
24609
- } catch (const native_exception &e) {
24610
- e.regenerate();
24611
- SWIG_fail;
24612
- } catch (const std::exception& e) {
24613
- SWIG_exception_fail(SWIG_RuntimeError, e.what());
24614
- }
24615
- }
24616
- vresult = rb_ary_new();
24617
- {
24618
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ< double,WGS84 >(*arg2)), SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN));
24619
- }
24620
- {
24621
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ< double,WGS84 >(*arg3)), SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN));
24622
- }
24623
- return vresult;
24624
- fail:
24625
- return Qnil;
24626
- }
24627
-
24628
-
24629
- SWIGINTERN VALUE
24630
- _wrap_Ephemeris_GLONASS_constellation__SWIG_1(int argc, VALUE *argv, VALUE self) {
24631
- GLONASS_Ephemeris< double > *arg1 = (GLONASS_Ephemeris< double > *) 0 ;
24632
- System_XYZ< double,WGS84 > *arg2 = 0 ;
24633
- System_XYZ< double,WGS84 > *arg3 = 0 ;
24634
- GPS_Time< double > *arg4 = 0 ;
24635
- void *argp1 = 0 ;
24636
- int res1 = 0 ;
24637
- System_XYZ< double,WGS84 > temp2 ;
24638
- System_XYZ< double,WGS84 > temp3 ;
24639
- void *argp4 ;
24640
- int res4 = 0 ;
24641
- VALUE vresult = Qnil;
24642
-
24643
-
24644
- arg2 = &temp2;
24645
-
24646
-
24647
- arg3 = &temp3;
24648
-
24649
- if ((argc < 1) || (argc > 1)) {
24650
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
24651
- }
24652
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLONASS_EphemerisT_double_t, 0 | 0 );
24653
- if (!SWIG_IsOK(res1)) {
24654
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GLONASS_Ephemeris< double > const *","constellation", 1, self ));
24655
- }
24656
- arg1 = reinterpret_cast< GLONASS_Ephemeris< double > * >(argp1);
24657
- res4 = SWIG_ConvertPtr(argv[0], &argp4, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
24658
- if (!SWIG_IsOK(res4)) {
24659
- SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "GPS_Time< double > const &","constellation", 4, argv[0] ));
24660
- }
24661
- if (!argp4) {
24662
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","constellation", 4, argv[0]));
24663
- }
24664
- arg4 = reinterpret_cast< GPS_Time< double > * >(argp4);
24665
- {
24666
- try {
24667
- GLONASS_Ephemeris_Sl_double_Sg__constellation__SWIG_0((GLONASS_Ephemeris< double > const *)arg1,*arg2,*arg3,(GPS_Time< double > const &)*arg4);
24668
- } catch (const native_exception &e) {
24669
- e.regenerate();
24670
- SWIG_fail;
24671
- } catch (const std::exception& e) {
24672
- SWIG_exception_fail(SWIG_RuntimeError, e.what());
24673
- }
24674
- }
24675
- vresult = rb_ary_new();
24676
- {
24677
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ< double,WGS84 >(*arg2)), SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN));
24678
- }
24679
- {
24680
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ< double,WGS84 >(*arg3)), SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN));
24377
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ<double, WGS84>((&result)->position)),
24378
+ SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN))
24379
+
24380
+ ;
24381
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new System_XYZ<double, WGS84>((&result)->velocity)),
24382
+ SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN))
24383
+
24384
+ ;
24385
+ vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((&result)->clock_error));
24386
+ vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((&result)->clock_error_dot));
24681
24387
  }
24682
24388
  return vresult;
24683
24389
  fail:
@@ -24733,8 +24439,8 @@ SWIGINTERN VALUE _wrap_Ephemeris_GLONASS_constellation(int nargs, VALUE *args, V
24733
24439
 
24734
24440
  fail:
24735
24441
  Ruby_Format_OverloadedError( argc, 4, "constellation",
24736
- " void constellation(System_XYZ< double,WGS84 > &position, System_XYZ< double,WGS84 > &velocity, GPS_Time< double > const &t, double const &pseudo_range)\n"
24737
- " void constellation(System_XYZ< double,WGS84 > &position, System_XYZ< double,WGS84 > &velocity, GPS_Time< double > const &t)\n");
24442
+ " GPS_Ephemeris< double >::constellation_res_t constellation(GPS_Time< double > const &t_tx, double const &dt_transit)\n"
24443
+ " GPS_Ephemeris< double >::constellation_res_t constellation(GPS_Time< double > const &t_tx)\n");
24738
24444
 
24739
24445
  return Qnil;
24740
24446
  }
@@ -26836,7 +26542,6 @@ SWIGEXPORT void Init_GPS(void) {
26836
26542
  rb_define_method(SwigClassEphemeris_GLONASS.klass, "frequency_L2", VALUEFUNC(_wrap_Ephemeris_GLONASS_frequency_L2), -1);
26837
26543
  rb_define_method(SwigClassEphemeris_GLONASS.klass, "base_time", VALUEFUNC(_wrap_Ephemeris_GLONASS_base_time), -1);
26838
26544
  rb_define_method(SwigClassEphemeris_GLONASS.klass, "parse", VALUEFUNC(_wrap_Ephemeris_GLONASS_parse), -1);
26839
- rb_define_method(SwigClassEphemeris_GLONASS.klass, "clock_error", VALUEFUNC(_wrap_Ephemeris_GLONASS_clock_error), -1);
26840
26545
  rb_define_method(SwigClassEphemeris_GLONASS.klass, "constellation", VALUEFUNC(_wrap_Ephemeris_GLONASS_constellation), -1);
26841
26546
  rb_define_method(SwigClassEphemeris_GLONASS.klass, "in_range?", VALUEFUNC(_wrap_Ephemeris_GLONASS_in_rangeq___), -1);
26842
26547
  SwigClassEphemeris_GLONASS.mark = 0;