gps_pvt 0.9.4 → 0.10.1
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/README.md +9 -7
- data/Rakefile +18 -1
- data/exe/gps2ubx +12 -5
- data/exe/gps_pvt +7 -2
- data/ext/gps_pvt/GPS/GPS_wrap.cxx +837 -52
- data/ext/ninja-scan-light/tool/navigation/GLONASS_Solver.h +11 -3
- data/ext/ninja-scan-light/tool/navigation/GPS.h +2 -1
- data/ext/ninja-scan-light/tool/navigation/GPS_Solver.h +20 -16
- data/ext/ninja-scan-light/tool/navigation/GPS_Solver_Base.h +84 -46
- data/ext/ninja-scan-light/tool/navigation/GPS_Solver_RAIM.h +2 -1
- data/ext/ninja-scan-light/tool/navigation/SBAS_Solver.h +10 -2
- data/ext/ninja-scan-light/tool/swig/GPS.i +76 -5
- data/ext/ninja-scan-light/tool/swig/spec/GPS_spec.rb +7 -7
- data/gps_pvt.gemspec +3 -2
- data/lib/gps_pvt/asn1/asn1.rb +888 -0
- data/lib/gps_pvt/asn1/asn1.y +903 -0
- data/lib/gps_pvt/asn1/per.rb +182 -0
- data/lib/gps_pvt/receiver/agps.rb +31 -0
- data/lib/gps_pvt/receiver/extension.rb +21 -0
- data/lib/gps_pvt/receiver/rtcm3.rb +2 -1
- data/lib/gps_pvt/receiver.rb +28 -20
- data/lib/gps_pvt/rtcm3.rb +17 -32
- data/lib/gps_pvt/supl.rb +567 -0
- data/lib/gps_pvt/ubx.rb +15 -0
- data/lib/gps_pvt/upl/LPP-V17_5_0-Release17.asn +6441 -0
- data/lib/gps_pvt/upl/RRLP-V17_0_0-Release17.asn +2780 -0
- data/lib/gps_pvt/upl/ULP-V2_0_6-20200720-D.asn +2185 -0
- data/lib/gps_pvt/upl/upl.json.gz +0 -0
- data/lib/gps_pvt/upl/upl.rb +99 -0
- data/lib/gps_pvt/util.rb +1 -0
- data/lib/gps_pvt/version.rb +1 -1
- metadata +26 -2
@@ -2377,6 +2377,22 @@ struct GPS_Ephemeris : public GPS_SpaceNode<FloatT>::SatelliteProperties::Epheme
|
|
2377
2377
|
System_XYZ<FloatT, WGS84> position, velocity;
|
2378
2378
|
FloatT clock_error, clock_error_dot;
|
2379
2379
|
};
|
2380
|
+
|
2381
|
+
int get_URA_index() const {
|
2382
|
+
return GPS_Ephemeris<FloatT>::URA_index(this->URA);
|
2383
|
+
}
|
2384
|
+
int set_URA_index(const int &idx) {
|
2385
|
+
this->URA = GPS_Ephemeris<FloatT>::URA_meter(idx);
|
2386
|
+
return get_URA_index();
|
2387
|
+
}
|
2388
|
+
FloatT set_fit_interval(const bool &flag) {
|
2389
|
+
// set svid/iodc before invocation of this function
|
2390
|
+
if((this->svid >= 193) && (this->svid <= 202)){ // QZSS
|
2391
|
+
return (this->fit_interval = (flag ? (std::numeric_limits<FloatT>::max)() : (2 * 60 * 60)));
|
2392
|
+
}else{
|
2393
|
+
return (this->fit_interval = GPS_Ephemeris<FloatT>::raw_t::fit_interval(flag, this->iodc));
|
2394
|
+
}
|
2395
|
+
}
|
2380
2396
|
};
|
2381
2397
|
|
2382
2398
|
|
@@ -2392,6 +2408,13 @@ struct SBAS_Ephemeris : public SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephe
|
|
2392
2408
|
return SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris::is_valid(t);
|
2393
2409
|
}
|
2394
2410
|
GPS_Time<FloatT> t_applicable() const {return GPS_Time<FloatT>(this->WN, this->t_0);}
|
2411
|
+
int get_URA_index() const {
|
2412
|
+
return SBAS_Ephemeris<FloatT>::URA_index(this->URA);
|
2413
|
+
}
|
2414
|
+
int set_URA_index(const int &idx) {
|
2415
|
+
this->URA = SBAS_Ephemeris<FloatT>::URA_meter(idx);
|
2416
|
+
return get_URA_index();
|
2417
|
+
}
|
2395
2418
|
};
|
2396
2419
|
|
2397
2420
|
|
@@ -2432,6 +2455,21 @@ struct GLONASS_Ephemeris
|
|
2432
2455
|
(typename GLONASS_SpaceNode<FloatT>::TimeProperties)(*this)),
|
2433
2456
|
deltaT));
|
2434
2457
|
}
|
2458
|
+
|
2459
|
+
unsigned char get_F_T_index() const {
|
2460
|
+
return GLONASS_Ephemeris<FloatT>::F_T_index();
|
2461
|
+
}
|
2462
|
+
unsigned char set_F_T_index(const unsigned char &idx) {
|
2463
|
+
this->F_T = GLONASS_Ephemeris<FloatT>::raw_t::F_T_value(idx);
|
2464
|
+
return get_F_T_index();
|
2465
|
+
}
|
2466
|
+
unsigned char get_P1_index() const {
|
2467
|
+
return GLONASS_Ephemeris<FloatT>::P1_index();
|
2468
|
+
}
|
2469
|
+
unsigned char set_P1_index(const unsigned char &idx) {
|
2470
|
+
this->P1 = GLONASS_Ephemeris<FloatT>::raw_t::P1_value(idx);
|
2471
|
+
return get_P1_index();
|
2472
|
+
}
|
2435
2473
|
};
|
2436
2474
|
|
2437
2475
|
|
@@ -2469,6 +2507,10 @@ struct GPS_User_PVT
|
|
2469
2507
|
const FloatT &hdop() const {return base_t::dop.h;}
|
2470
2508
|
const FloatT &vdop() const {return base_t::dop.v;}
|
2471
2509
|
const FloatT &tdop() const {return base_t::dop.t;}
|
2510
|
+
const FloatT &hsigma() const {return base_t::sigma_pos.h;}
|
2511
|
+
const FloatT &vsigma() const {return base_t::sigma_pos.v;}
|
2512
|
+
const FloatT &tsigma() const {return base_t::sigma_pos.t;}
|
2513
|
+
const FloatT &vel_sigma() const {return base_t::sigma_vel.p;}
|
2472
2514
|
const unsigned int &used_satellites() const {return base_t::used_satellites;}
|
2473
2515
|
std::vector<int> used_satellite_list() const {return base_t::used_satellite_mask.indices_one();}
|
2474
2516
|
bool position_solved() const {return base_t::position_solved();}
|
@@ -2493,7 +2535,7 @@ struct GPS_User_PVT
|
|
2493
2535
|
return linear_solver().C();
|
2494
2536
|
}
|
2495
2537
|
Matrix<FloatT, Array2D_Dense<FloatT> > C_enu() const {
|
2496
|
-
return proxy_t::linear_solver_t::
|
2538
|
+
return proxy_t::linear_solver_t::rotate_CP(C(), base_t::user_position.ecef2enu());
|
2497
2539
|
}
|
2498
2540
|
Matrix<FloatT, Array2D_Dense<FloatT> > S() const {
|
2499
2541
|
Matrix<FloatT, Array2D_Dense<FloatT> > res;
|
@@ -3837,7 +3879,7 @@ SWIGINTERN double GPS_Ephemeris_Sl_double_Sg__set_t_oe(GPS_Ephemeris< double > *
|
|
3837
3879
|
SWIGINTERN double const &GPS_Ephemeris_Sl_double_Sg__get_t_oe(GPS_Ephemeris< double > const *self){
|
3838
3880
|
return self->t_oe;
|
3839
3881
|
}
|
3840
|
-
SWIGINTERN double
|
3882
|
+
SWIGINTERN double GPS_Ephemeris_Sl_double_Sg__set_fit_interval__SWIG_1(GPS_Ephemeris< double > *self,double const &v){
|
3841
3883
|
return self->fit_interval= v;
|
3842
3884
|
}
|
3843
3885
|
SWIGINTERN double const &GPS_Ephemeris_Sl_double_Sg__get_fit_interval(GPS_Ephemeris< double > const *self){
|
@@ -4139,6 +4181,12 @@ SWIGINTERN double GPS_SolverOptions_Common_Sl_double_Sg__set_residual_mask(GPS_S
|
|
4139
4181
|
SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_residual_mask(GPS_SolverOptions_Common< double > const *self){
|
4140
4182
|
return self->cast_general()->residual_mask;
|
4141
4183
|
}
|
4184
|
+
SWIGINTERN bool GPS_SolverOptions_Common_Sl_double_Sg__set_use_external_sigma(GPS_SolverOptions_Common< double > *self,bool const &v){
|
4185
|
+
return self->cast_general()->use_external_sigma= v;
|
4186
|
+
}
|
4187
|
+
SWIGINTERN bool const &GPS_SolverOptions_Common_Sl_double_Sg__get_use_external_sigma(GPS_SolverOptions_Common< double > const *self){
|
4188
|
+
return self->cast_general()->use_external_sigma;
|
4189
|
+
}
|
4142
4190
|
|
4143
4191
|
template <> template <>
|
4144
4192
|
HookableSolver<
|
@@ -4166,7 +4214,7 @@ SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_residual_mas
|
|
4166
4214
|
const GPS_Solver<double>::base_t::relative_property_t &res_orig) const {
|
4167
4215
|
union {
|
4168
4216
|
base_t::relative_property_t prop;
|
4169
|
-
double values[
|
4217
|
+
double values[8];
|
4170
4218
|
} res = {res_orig};
|
4171
4219
|
|
4172
4220
|
do{
|
@@ -4174,15 +4222,19 @@ SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_residual_mas
|
|
4174
4222
|
static const int prop_items(sizeof(res.values) / sizeof(res.values[0]));
|
4175
4223
|
VALUE hook(rb_hash_lookup(hooks, key));
|
4176
4224
|
if(NIL_P(hook)){break;}
|
4177
|
-
double
|
4225
|
+
double weight_range((res.prop.range_sigma > 0)
|
4178
4226
|
? (1. / std::pow(res.prop.range_sigma, 2)) // weight=1/(sigma^2)
|
4179
4227
|
: res.prop.range_sigma);
|
4228
|
+
double weight_rate((res.prop.rate_sigma > 0)
|
4229
|
+
? (1. / std::pow(res.prop.rate_sigma, 2)) // weight=1/(sigma^2)
|
4230
|
+
: res.prop.rate_sigma);
|
4180
4231
|
VALUE values[] = {
|
4181
4232
|
SWIG_From_int (prn), // prn
|
4182
4233
|
rb_ary_new_from_args(prop_items, // relative_property
|
4183
|
-
swig::from(
|
4234
|
+
swig::from(weight_range),
|
4184
4235
|
swig::from(res.prop.range_corrected),
|
4185
4236
|
swig::from(res.prop.range_residual),
|
4237
|
+
swig::from(weight_rate),
|
4186
4238
|
swig::from(res.prop.rate_relative_neg),
|
4187
4239
|
swig::from(res.prop.los_neg[0]),
|
4188
4240
|
swig::from(res.prop.los_neg[1]),
|
@@ -4215,6 +4267,9 @@ SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_residual_mas
|
|
4215
4267
|
if(res.values[0] > 0){
|
4216
4268
|
res.values[0] = std::pow(1. / res.values[0], 0.5); // sigma=(1/weight)^0.5
|
4217
4269
|
}
|
4270
|
+
if(res.values[3] > 0){
|
4271
|
+
res.values[3] = std::pow(1. / res.values[3], 0.5); // sigma=(1/weight)^0.5
|
4272
|
+
}
|
4218
4273
|
}while(false);
|
4219
4274
|
|
4220
4275
|
return res.prop;
|
@@ -4562,6 +4617,29 @@ SWIGINTERN int GLONASS_SpaceNode_Sl_double_Sg__read(GLONASS_SpaceNode< double >
|
|
4562
4617
|
list.glonass = self;
|
4563
4618
|
return RINEX_NAV_Reader<double>::read_all(fin, list);
|
4564
4619
|
}
|
4620
|
+
|
4621
|
+
SWIGINTERNINLINE VALUE
|
4622
|
+
SWIG_From_unsigned_SS_char (unsigned char value)
|
4623
|
+
{
|
4624
|
+
return SWIG_From_unsigned_SS_long (value);
|
4625
|
+
}
|
4626
|
+
|
4627
|
+
|
4628
|
+
SWIGINTERN int
|
4629
|
+
SWIG_AsVal_unsigned_SS_char (VALUE obj, unsigned char *val)
|
4630
|
+
{
|
4631
|
+
unsigned long v;
|
4632
|
+
int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
|
4633
|
+
if (SWIG_IsOK(res)) {
|
4634
|
+
if ((v > UCHAR_MAX)) {
|
4635
|
+
return SWIG_OverflowError;
|
4636
|
+
} else {
|
4637
|
+
if (val) *val = static_cast< unsigned char >(v);
|
4638
|
+
}
|
4639
|
+
}
|
4640
|
+
return res;
|
4641
|
+
}
|
4642
|
+
|
4565
4643
|
SWIGINTERN unsigned int GLONASS_Ephemeris_Sl_double_Sg__set_svid(GLONASS_Ephemeris< double > *self,unsigned int const &v){
|
4566
4644
|
return self->svid= v;
|
4567
4645
|
}
|
@@ -4748,6 +4826,23 @@ SWIGINTERN void GLONASS_Ephemeris_Sl_double_Sg__set_date__SWIG_0(GLONASS_Ephemer
|
|
4748
4826
|
SWIGINTERN void GLONASS_Ephemeris_Sl_double_Sg__set_date__SWIG_1(GLONASS_Ephemeris< double > *self,std::tm const &t){
|
4749
4827
|
self->date = GLONASS_SpaceNode<double>::TimeProperties::date_t::from_c_tm(t);
|
4750
4828
|
}
|
4829
|
+
SWIGINTERN unsigned char GLONASS_Ephemeris_Sl_double_Sg__N_4(GLONASS_Ephemeris< double > const *self){
|
4830
|
+
unsigned char res;
|
4831
|
+
GLONASS_Ephemeris<double>::TimeProperties::raw_t::date2raw(self->date, &res, NULL);
|
4832
|
+
return res;
|
4833
|
+
}
|
4834
|
+
SWIGINTERN unsigned short GLONASS_Ephemeris_Sl_double_Sg__NA(GLONASS_Ephemeris< double > const *self){
|
4835
|
+
unsigned short res;
|
4836
|
+
GLONASS_Ephemeris<double>::TimeProperties::raw_t::date2raw(self->date, NULL, &res);
|
4837
|
+
return res;
|
4838
|
+
}
|
4839
|
+
|
4840
|
+
SWIGINTERNINLINE VALUE
|
4841
|
+
SWIG_From_unsigned_SS_short (unsigned short value)
|
4842
|
+
{
|
4843
|
+
return SWIG_From_unsigned_SS_long (value);
|
4844
|
+
}
|
4845
|
+
|
4751
4846
|
SWIGINTERN double GLONASS_Ephemeris_Sl_double_Sg__frequency_L1(GLONASS_Ephemeris< double > const *self){
|
4752
4847
|
return self->L1_frequency();
|
4753
4848
|
}
|
@@ -10661,6 +10756,126 @@ fail:
|
|
10661
10756
|
}
|
10662
10757
|
|
10663
10758
|
|
10759
|
+
/*
|
10760
|
+
Document-method: GPS_PVT::GPS::Ephemeris.URA_index
|
10761
|
+
|
10762
|
+
call-seq:
|
10763
|
+
URA_index -> int
|
10764
|
+
|
10765
|
+
An instance method.
|
10766
|
+
|
10767
|
+
*/
|
10768
|
+
SWIGINTERN VALUE
|
10769
|
+
_wrap_Ephemeris_URA_index(int argc, VALUE *argv, VALUE self) {
|
10770
|
+
GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
|
10771
|
+
void *argp1 = 0 ;
|
10772
|
+
int res1 = 0 ;
|
10773
|
+
int result;
|
10774
|
+
VALUE vresult = Qnil;
|
10775
|
+
|
10776
|
+
if ((argc < 0) || (argc > 0)) {
|
10777
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
10778
|
+
}
|
10779
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_EphemerisT_double_t, 0 | 0 );
|
10780
|
+
if (!SWIG_IsOK(res1)) {
|
10781
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_URA_index", 1, self ));
|
10782
|
+
}
|
10783
|
+
arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
|
10784
|
+
result = (int)((GPS_Ephemeris< double > const *)arg1)->get_URA_index();
|
10785
|
+
vresult = SWIG_From_int(static_cast< int >(result));
|
10786
|
+
return vresult;
|
10787
|
+
fail:
|
10788
|
+
return Qnil;
|
10789
|
+
}
|
10790
|
+
|
10791
|
+
|
10792
|
+
/*
|
10793
|
+
Document-method: GPS_PVT::GPS::Ephemeris.URA_index=
|
10794
|
+
|
10795
|
+
call-seq:
|
10796
|
+
URA_index=(int const & idx) -> int
|
10797
|
+
|
10798
|
+
An instance method.
|
10799
|
+
|
10800
|
+
*/
|
10801
|
+
SWIGINTERN VALUE
|
10802
|
+
_wrap_Ephemeris_URA_indexe___(int argc, VALUE *argv, VALUE self) {
|
10803
|
+
GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
|
10804
|
+
int *arg2 = 0 ;
|
10805
|
+
void *argp1 = 0 ;
|
10806
|
+
int res1 = 0 ;
|
10807
|
+
int temp2 ;
|
10808
|
+
int val2 ;
|
10809
|
+
int ecode2 = 0 ;
|
10810
|
+
int result;
|
10811
|
+
VALUE vresult = Qnil;
|
10812
|
+
|
10813
|
+
if ((argc < 1) || (argc > 1)) {
|
10814
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
10815
|
+
}
|
10816
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_EphemerisT_double_t, 0 | 0 );
|
10817
|
+
if (!SWIG_IsOK(res1)) {
|
10818
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_URA_index", 1, self ));
|
10819
|
+
}
|
10820
|
+
arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
|
10821
|
+
ecode2 = SWIG_AsVal_int(argv[0], &val2);
|
10822
|
+
if (!SWIG_IsOK(ecode2)) {
|
10823
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","set_URA_index", 2, argv[0] ));
|
10824
|
+
}
|
10825
|
+
temp2 = static_cast< int >(val2);
|
10826
|
+
arg2 = &temp2;
|
10827
|
+
result = (int)(arg1)->set_URA_index((int const &)*arg2);
|
10828
|
+
vresult = SWIG_From_int(static_cast< int >(result));
|
10829
|
+
return vresult;
|
10830
|
+
fail:
|
10831
|
+
return Qnil;
|
10832
|
+
}
|
10833
|
+
|
10834
|
+
|
10835
|
+
/*
|
10836
|
+
Document-method: GPS_PVT::GPS::Ephemeris.fit_interval=
|
10837
|
+
|
10838
|
+
call-seq:
|
10839
|
+
fit_interval=(bool const & flag) -> double
|
10840
|
+
fit_interval=(double const & v) -> double
|
10841
|
+
|
10842
|
+
An instance method.
|
10843
|
+
|
10844
|
+
*/
|
10845
|
+
SWIGINTERN VALUE
|
10846
|
+
_wrap_Ephemeris_fit_intervale_____SWIG_0(int argc, VALUE *argv, VALUE self) {
|
10847
|
+
GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
|
10848
|
+
bool *arg2 = 0 ;
|
10849
|
+
void *argp1 = 0 ;
|
10850
|
+
int res1 = 0 ;
|
10851
|
+
bool temp2 ;
|
10852
|
+
bool val2 ;
|
10853
|
+
int ecode2 = 0 ;
|
10854
|
+
double result;
|
10855
|
+
VALUE vresult = Qnil;
|
10856
|
+
|
10857
|
+
if ((argc < 1) || (argc > 1)) {
|
10858
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
10859
|
+
}
|
10860
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_EphemerisT_double_t, 0 | 0 );
|
10861
|
+
if (!SWIG_IsOK(res1)) {
|
10862
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_fit_interval", 1, self ));
|
10863
|
+
}
|
10864
|
+
arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
|
10865
|
+
ecode2 = SWIG_AsVal_bool(argv[0], &val2);
|
10866
|
+
if (!SWIG_IsOK(ecode2)) {
|
10867
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","set_fit_interval", 2, argv[0] ));
|
10868
|
+
}
|
10869
|
+
temp2 = static_cast< bool >(val2);
|
10870
|
+
arg2 = &temp2;
|
10871
|
+
result = (double)(arg1)->set_fit_interval((bool const &)*arg2);
|
10872
|
+
vresult = SWIG_From_double(static_cast< double >(result));
|
10873
|
+
return vresult;
|
10874
|
+
fail:
|
10875
|
+
return Qnil;
|
10876
|
+
}
|
10877
|
+
|
10878
|
+
|
10664
10879
|
/*
|
10665
10880
|
Document-method: GPS_PVT::GPS::Ephemeris.svid=
|
10666
10881
|
|
@@ -12109,13 +12324,14 @@ fail:
|
|
12109
12324
|
Document-method: GPS_PVT::GPS::Ephemeris.fit_interval=
|
12110
12325
|
|
12111
12326
|
call-seq:
|
12327
|
+
fit_interval=(bool const & flag) -> double
|
12112
12328
|
fit_interval=(double const & v) -> double
|
12113
12329
|
|
12114
12330
|
An instance method.
|
12115
12331
|
|
12116
12332
|
*/
|
12117
12333
|
SWIGINTERN VALUE
|
12118
|
-
|
12334
|
+
_wrap_Ephemeris_fit_intervale_____SWIG_1(int argc, VALUE *argv, VALUE self) {
|
12119
12335
|
GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
|
12120
12336
|
double *arg2 = 0 ;
|
12121
12337
|
void *argp1 = 0 ;
|
@@ -12140,7 +12356,7 @@ _wrap_Ephemeris_fit_intervale___(int argc, VALUE *argv, VALUE self) {
|
|
12140
12356
|
}
|
12141
12357
|
temp2 = static_cast< double >(val2);
|
12142
12358
|
arg2 = &temp2;
|
12143
|
-
result = (double)
|
12359
|
+
result = (double)GPS_Ephemeris_Sl_double_Sg__set_fit_interval__SWIG_1(arg1,(double const &)*arg2);
|
12144
12360
|
vresult = SWIG_From_double(static_cast< double >(result));
|
12145
12361
|
return vresult;
|
12146
12362
|
fail:
|
@@ -12148,6 +12364,57 @@ fail:
|
|
12148
12364
|
}
|
12149
12365
|
|
12150
12366
|
|
12367
|
+
SWIGINTERN VALUE _wrap_Ephemeris_fit_intervale___(int nargs, VALUE *args, VALUE self) {
|
12368
|
+
int argc;
|
12369
|
+
VALUE argv[3];
|
12370
|
+
int ii;
|
12371
|
+
|
12372
|
+
argc = nargs + 1;
|
12373
|
+
argv[0] = self;
|
12374
|
+
if (argc > 3) SWIG_fail;
|
12375
|
+
for (ii = 1; (ii < argc); ++ii) {
|
12376
|
+
argv[ii] = args[ii-1];
|
12377
|
+
}
|
12378
|
+
if (argc == 2) {
|
12379
|
+
int _v;
|
12380
|
+
void *vptr = 0;
|
12381
|
+
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_EphemerisT_double_t, 0);
|
12382
|
+
_v = SWIG_CheckState(res);
|
12383
|
+
if (_v) {
|
12384
|
+
{
|
12385
|
+
int res = SWIG_AsVal_double(argv[1], NULL);
|
12386
|
+
_v = SWIG_CheckState(res);
|
12387
|
+
}
|
12388
|
+
if (_v) {
|
12389
|
+
return _wrap_Ephemeris_fit_intervale_____SWIG_1(nargs, args, self);
|
12390
|
+
}
|
12391
|
+
}
|
12392
|
+
}
|
12393
|
+
if (argc == 2) {
|
12394
|
+
int _v;
|
12395
|
+
void *vptr = 0;
|
12396
|
+
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_EphemerisT_double_t, 0);
|
12397
|
+
_v = SWIG_CheckState(res);
|
12398
|
+
if (_v) {
|
12399
|
+
{
|
12400
|
+
int res = SWIG_AsVal_bool(argv[1], NULL);
|
12401
|
+
_v = SWIG_CheckState(res);
|
12402
|
+
}
|
12403
|
+
if (_v) {
|
12404
|
+
return _wrap_Ephemeris_fit_intervale_____SWIG_0(nargs, args, self);
|
12405
|
+
}
|
12406
|
+
}
|
12407
|
+
}
|
12408
|
+
|
12409
|
+
fail:
|
12410
|
+
Ruby_Format_OverloadedError( argc, 3, "Ephemeris.fit_interval=",
|
12411
|
+
" double Ephemeris.fit_interval=(bool const &flag)\n"
|
12412
|
+
" double Ephemeris.fit_interval=(double const &v)\n");
|
12413
|
+
|
12414
|
+
return Qnil;
|
12415
|
+
}
|
12416
|
+
|
12417
|
+
|
12151
12418
|
/*
|
12152
12419
|
Document-method: GPS_PVT::GPS::Ephemeris.fit_interval
|
12153
12420
|
|
@@ -13842,20 +14109,20 @@ fail:
|
|
13842
14109
|
|
13843
14110
|
|
13844
14111
|
/*
|
13845
|
-
Document-method: GPS_PVT::GPS::PVT.
|
14112
|
+
Document-method: GPS_PVT::GPS::PVT.hsigma
|
13846
14113
|
|
13847
14114
|
call-seq:
|
13848
|
-
|
14115
|
+
hsigma -> double const &
|
13849
14116
|
|
13850
14117
|
An instance method.
|
13851
14118
|
|
13852
14119
|
*/
|
13853
14120
|
SWIGINTERN VALUE
|
13854
|
-
|
14121
|
+
_wrap_PVT_hsigma(int argc, VALUE *argv, VALUE self) {
|
13855
14122
|
GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
|
13856
14123
|
void *argp1 = 0 ;
|
13857
14124
|
int res1 = 0 ;
|
13858
|
-
|
14125
|
+
double *result = 0 ;
|
13859
14126
|
VALUE vresult = Qnil;
|
13860
14127
|
|
13861
14128
|
if ((argc < 0) || (argc > 0)) {
|
@@ -13863,11 +14130,11 @@ _wrap_PVT_used_satellites(int argc, VALUE *argv, VALUE self) {
|
|
13863
14130
|
}
|
13864
14131
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_User_PVTT_double_t, 0 | 0 );
|
13865
14132
|
if (!SWIG_IsOK(res1)) {
|
13866
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","
|
14133
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","hsigma", 1, self ));
|
13867
14134
|
}
|
13868
14135
|
arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
|
13869
|
-
result = (
|
13870
|
-
vresult =
|
14136
|
+
result = (double *) &((GPS_User_PVT< double > const *)arg1)->hsigma();
|
14137
|
+
vresult = SWIG_From_double(static_cast< double >(*result));
|
13871
14138
|
return vresult;
|
13872
14139
|
fail:
|
13873
14140
|
return Qnil;
|
@@ -13875,20 +14142,20 @@ fail:
|
|
13875
14142
|
|
13876
14143
|
|
13877
14144
|
/*
|
13878
|
-
Document-method: GPS_PVT::GPS::PVT.
|
14145
|
+
Document-method: GPS_PVT::GPS::PVT.vsigma
|
13879
14146
|
|
13880
14147
|
call-seq:
|
13881
|
-
|
14148
|
+
vsigma -> double const &
|
13882
14149
|
|
13883
14150
|
An instance method.
|
13884
14151
|
|
13885
14152
|
*/
|
13886
14153
|
SWIGINTERN VALUE
|
13887
|
-
|
14154
|
+
_wrap_PVT_vsigma(int argc, VALUE *argv, VALUE self) {
|
13888
14155
|
GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
|
13889
14156
|
void *argp1 = 0 ;
|
13890
14157
|
int res1 = 0 ;
|
13891
|
-
|
14158
|
+
double *result = 0 ;
|
13892
14159
|
VALUE vresult = Qnil;
|
13893
14160
|
|
13894
14161
|
if ((argc < 0) || (argc > 0)) {
|
@@ -13896,18 +14163,11 @@ _wrap_PVT_used_satellite_list(int argc, VALUE *argv, VALUE self) {
|
|
13896
14163
|
}
|
13897
14164
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_User_PVTT_double_t, 0 | 0 );
|
13898
14165
|
if (!SWIG_IsOK(res1)) {
|
13899
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","
|
14166
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","vsigma", 1, self ));
|
13900
14167
|
}
|
13901
14168
|
arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
|
13902
|
-
result = ((GPS_User_PVT< double > const *)arg1)->
|
13903
|
-
|
13904
|
-
vresult = rb_ary_new();
|
13905
|
-
|
13906
|
-
for(std::vector< int >::const_iterator it((&result)->begin()), it_end((&result)->end());
|
13907
|
-
it != it_end; ++it){
|
13908
|
-
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int (*it));
|
13909
|
-
}
|
13910
|
-
}
|
14169
|
+
result = (double *) &((GPS_User_PVT< double > const *)arg1)->vsigma();
|
14170
|
+
vresult = SWIG_From_double(static_cast< double >(*result));
|
13911
14171
|
return vresult;
|
13912
14172
|
fail:
|
13913
14173
|
return Qnil;
|
@@ -13915,20 +14175,20 @@ fail:
|
|
13915
14175
|
|
13916
14176
|
|
13917
14177
|
/*
|
13918
|
-
Document-method: GPS_PVT::GPS::PVT.
|
14178
|
+
Document-method: GPS_PVT::GPS::PVT.tsigma
|
13919
14179
|
|
13920
14180
|
call-seq:
|
13921
|
-
|
14181
|
+
tsigma -> double const &
|
13922
14182
|
|
13923
14183
|
An instance method.
|
13924
14184
|
|
13925
14185
|
*/
|
13926
14186
|
SWIGINTERN VALUE
|
13927
|
-
|
14187
|
+
_wrap_PVT_tsigma(int argc, VALUE *argv, VALUE self) {
|
13928
14188
|
GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
|
13929
14189
|
void *argp1 = 0 ;
|
13930
14190
|
int res1 = 0 ;
|
13931
|
-
|
14191
|
+
double *result = 0 ;
|
13932
14192
|
VALUE vresult = Qnil;
|
13933
14193
|
|
13934
14194
|
if ((argc < 0) || (argc > 0)) {
|
@@ -13936,11 +14196,11 @@ _wrap_PVT_position_solvedq___(int argc, VALUE *argv, VALUE self) {
|
|
13936
14196
|
}
|
13937
14197
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_User_PVTT_double_t, 0 | 0 );
|
13938
14198
|
if (!SWIG_IsOK(res1)) {
|
13939
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","
|
14199
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","tsigma", 1, self ));
|
13940
14200
|
}
|
13941
14201
|
arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
|
13942
|
-
result = (
|
13943
|
-
vresult =
|
14202
|
+
result = (double *) &((GPS_User_PVT< double > const *)arg1)->tsigma();
|
14203
|
+
vresult = SWIG_From_double(static_cast< double >(*result));
|
13944
14204
|
return vresult;
|
13945
14205
|
fail:
|
13946
14206
|
return Qnil;
|
@@ -13948,20 +14208,20 @@ fail:
|
|
13948
14208
|
|
13949
14209
|
|
13950
14210
|
/*
|
13951
|
-
Document-method: GPS_PVT::GPS::PVT.
|
14211
|
+
Document-method: GPS_PVT::GPS::PVT.vel_sigma
|
13952
14212
|
|
13953
14213
|
call-seq:
|
13954
|
-
|
14214
|
+
vel_sigma -> double const &
|
13955
14215
|
|
13956
14216
|
An instance method.
|
13957
14217
|
|
13958
14218
|
*/
|
13959
14219
|
SWIGINTERN VALUE
|
13960
|
-
|
14220
|
+
_wrap_PVT_vel_sigma(int argc, VALUE *argv, VALUE self) {
|
13961
14221
|
GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
|
13962
14222
|
void *argp1 = 0 ;
|
13963
14223
|
int res1 = 0 ;
|
13964
|
-
|
14224
|
+
double *result = 0 ;
|
13965
14225
|
VALUE vresult = Qnil;
|
13966
14226
|
|
13967
14227
|
if ((argc < 0) || (argc > 0)) {
|
@@ -13969,11 +14229,11 @@ _wrap_PVT_velocity_solvedq___(int argc, VALUE *argv, VALUE self) {
|
|
13969
14229
|
}
|
13970
14230
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_User_PVTT_double_t, 0 | 0 );
|
13971
14231
|
if (!SWIG_IsOK(res1)) {
|
13972
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","
|
14232
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","vel_sigma", 1, self ));
|
13973
14233
|
}
|
13974
14234
|
arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
|
13975
|
-
result = (
|
13976
|
-
vresult =
|
14235
|
+
result = (double *) &((GPS_User_PVT< double > const *)arg1)->vel_sigma();
|
14236
|
+
vresult = SWIG_From_double(static_cast< double >(*result));
|
13977
14237
|
return vresult;
|
13978
14238
|
fail:
|
13979
14239
|
return Qnil;
|
@@ -13981,20 +14241,20 @@ fail:
|
|
13981
14241
|
|
13982
14242
|
|
13983
14243
|
/*
|
13984
|
-
Document-method: GPS_PVT::GPS::PVT.
|
14244
|
+
Document-method: GPS_PVT::GPS::PVT.used_satellites
|
13985
14245
|
|
13986
14246
|
call-seq:
|
13987
|
-
|
14247
|
+
used_satellites -> unsigned int const &
|
13988
14248
|
|
13989
14249
|
An instance method.
|
13990
14250
|
|
13991
14251
|
*/
|
13992
14252
|
SWIGINTERN VALUE
|
13993
|
-
|
14253
|
+
_wrap_PVT_used_satellites(int argc, VALUE *argv, VALUE self) {
|
13994
14254
|
GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
|
13995
14255
|
void *argp1 = 0 ;
|
13996
14256
|
int res1 = 0 ;
|
13997
|
-
|
14257
|
+
unsigned int *result = 0 ;
|
13998
14258
|
VALUE vresult = Qnil;
|
13999
14259
|
|
14000
14260
|
if ((argc < 0) || (argc > 0)) {
|
@@ -14002,11 +14262,11 @@ _wrap_PVT_G(int argc, VALUE *argv, VALUE self) {
|
|
14002
14262
|
}
|
14003
14263
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_User_PVTT_double_t, 0 | 0 );
|
14004
14264
|
if (!SWIG_IsOK(res1)) {
|
14005
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","
|
14265
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","used_satellites", 1, self ));
|
14006
14266
|
}
|
14007
14267
|
arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
|
14008
|
-
result = (
|
14009
|
-
vresult =
|
14268
|
+
result = (unsigned int *) &((GPS_User_PVT< double > const *)arg1)->used_satellites();
|
14269
|
+
vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(*result));
|
14010
14270
|
return vresult;
|
14011
14271
|
fail:
|
14012
14272
|
return Qnil;
|
@@ -14014,16 +14274,155 @@ fail:
|
|
14014
14274
|
|
14015
14275
|
|
14016
14276
|
/*
|
14017
|
-
Document-method: GPS_PVT::GPS::PVT.
|
14277
|
+
Document-method: GPS_PVT::GPS::PVT.used_satellite_list
|
14018
14278
|
|
14019
14279
|
call-seq:
|
14020
|
-
|
14280
|
+
used_satellite_list -> std::vector< int >
|
14021
14281
|
|
14022
14282
|
An instance method.
|
14023
14283
|
|
14024
14284
|
*/
|
14025
14285
|
SWIGINTERN VALUE
|
14026
|
-
|
14286
|
+
_wrap_PVT_used_satellite_list(int argc, VALUE *argv, VALUE self) {
|
14287
|
+
GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
|
14288
|
+
void *argp1 = 0 ;
|
14289
|
+
int res1 = 0 ;
|
14290
|
+
std::vector< int > result;
|
14291
|
+
VALUE vresult = Qnil;
|
14292
|
+
|
14293
|
+
if ((argc < 0) || (argc > 0)) {
|
14294
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
14295
|
+
}
|
14296
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_User_PVTT_double_t, 0 | 0 );
|
14297
|
+
if (!SWIG_IsOK(res1)) {
|
14298
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","used_satellite_list", 1, self ));
|
14299
|
+
}
|
14300
|
+
arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
|
14301
|
+
result = ((GPS_User_PVT< double > const *)arg1)->used_satellite_list();
|
14302
|
+
{
|
14303
|
+
vresult = rb_ary_new();
|
14304
|
+
|
14305
|
+
for(std::vector< int >::const_iterator it((&result)->begin()), it_end((&result)->end());
|
14306
|
+
it != it_end; ++it){
|
14307
|
+
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int (*it));
|
14308
|
+
}
|
14309
|
+
}
|
14310
|
+
return vresult;
|
14311
|
+
fail:
|
14312
|
+
return Qnil;
|
14313
|
+
}
|
14314
|
+
|
14315
|
+
|
14316
|
+
/*
|
14317
|
+
Document-method: GPS_PVT::GPS::PVT.position_solved?
|
14318
|
+
|
14319
|
+
call-seq:
|
14320
|
+
position_solved? -> bool
|
14321
|
+
|
14322
|
+
An instance method.
|
14323
|
+
|
14324
|
+
*/
|
14325
|
+
SWIGINTERN VALUE
|
14326
|
+
_wrap_PVT_position_solvedq___(int argc, VALUE *argv, VALUE self) {
|
14327
|
+
GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
|
14328
|
+
void *argp1 = 0 ;
|
14329
|
+
int res1 = 0 ;
|
14330
|
+
bool result;
|
14331
|
+
VALUE vresult = Qnil;
|
14332
|
+
|
14333
|
+
if ((argc < 0) || (argc > 0)) {
|
14334
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
14335
|
+
}
|
14336
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_User_PVTT_double_t, 0 | 0 );
|
14337
|
+
if (!SWIG_IsOK(res1)) {
|
14338
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","position_solved", 1, self ));
|
14339
|
+
}
|
14340
|
+
arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
|
14341
|
+
result = (bool)((GPS_User_PVT< double > const *)arg1)->position_solved();
|
14342
|
+
vresult = SWIG_From_bool(static_cast< bool >(result));
|
14343
|
+
return vresult;
|
14344
|
+
fail:
|
14345
|
+
return Qnil;
|
14346
|
+
}
|
14347
|
+
|
14348
|
+
|
14349
|
+
/*
|
14350
|
+
Document-method: GPS_PVT::GPS::PVT.velocity_solved?
|
14351
|
+
|
14352
|
+
call-seq:
|
14353
|
+
velocity_solved? -> bool
|
14354
|
+
|
14355
|
+
An instance method.
|
14356
|
+
|
14357
|
+
*/
|
14358
|
+
SWIGINTERN VALUE
|
14359
|
+
_wrap_PVT_velocity_solvedq___(int argc, VALUE *argv, VALUE self) {
|
14360
|
+
GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
|
14361
|
+
void *argp1 = 0 ;
|
14362
|
+
int res1 = 0 ;
|
14363
|
+
bool result;
|
14364
|
+
VALUE vresult = Qnil;
|
14365
|
+
|
14366
|
+
if ((argc < 0) || (argc > 0)) {
|
14367
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
14368
|
+
}
|
14369
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_User_PVTT_double_t, 0 | 0 );
|
14370
|
+
if (!SWIG_IsOK(res1)) {
|
14371
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","velocity_solved", 1, self ));
|
14372
|
+
}
|
14373
|
+
arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
|
14374
|
+
result = (bool)((GPS_User_PVT< double > const *)arg1)->velocity_solved();
|
14375
|
+
vresult = SWIG_From_bool(static_cast< bool >(result));
|
14376
|
+
return vresult;
|
14377
|
+
fail:
|
14378
|
+
return Qnil;
|
14379
|
+
}
|
14380
|
+
|
14381
|
+
|
14382
|
+
/*
|
14383
|
+
Document-method: GPS_PVT::GPS::PVT.G
|
14384
|
+
|
14385
|
+
call-seq:
|
14386
|
+
G -> Matrix_FrozenD
|
14387
|
+
|
14388
|
+
An instance method.
|
14389
|
+
|
14390
|
+
*/
|
14391
|
+
SWIGINTERN VALUE
|
14392
|
+
_wrap_PVT_G(int argc, VALUE *argv, VALUE self) {
|
14393
|
+
GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
|
14394
|
+
void *argp1 = 0 ;
|
14395
|
+
int res1 = 0 ;
|
14396
|
+
Matrix_Frozen< double,Array2D_Dense< double > > *result = 0 ;
|
14397
|
+
VALUE vresult = Qnil;
|
14398
|
+
|
14399
|
+
if ((argc < 0) || (argc > 0)) {
|
14400
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
14401
|
+
}
|
14402
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_User_PVTT_double_t, 0 | 0 );
|
14403
|
+
if (!SWIG_IsOK(res1)) {
|
14404
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","G", 1, self ));
|
14405
|
+
}
|
14406
|
+
arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
|
14407
|
+
result = (Matrix_Frozen< double,Array2D_Dense< double > > *) &((GPS_User_PVT< double > const *)arg1)->G();
|
14408
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 | 0 );
|
14409
|
+
return vresult;
|
14410
|
+
fail:
|
14411
|
+
return Qnil;
|
14412
|
+
}
|
14413
|
+
|
14414
|
+
|
14415
|
+
/*
|
14416
|
+
Document-method: GPS_PVT::GPS::PVT.W
|
14417
|
+
|
14418
|
+
call-seq:
|
14419
|
+
W -> Matrix_FrozenD
|
14420
|
+
|
14421
|
+
An instance method.
|
14422
|
+
|
14423
|
+
*/
|
14424
|
+
SWIGINTERN VALUE
|
14425
|
+
_wrap_PVT_W(int argc, VALUE *argv, VALUE self) {
|
14027
14426
|
GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
|
14028
14427
|
void *argp1 = 0 ;
|
14029
14428
|
int res1 = 0 ;
|
@@ -15474,6 +15873,82 @@ fail:
|
|
15474
15873
|
}
|
15475
15874
|
|
15476
15875
|
|
15876
|
+
/*
|
15877
|
+
Document-method: GPS_PVT::GPS::SolverOptionsCommon.use_external_sigma=
|
15878
|
+
|
15879
|
+
call-seq:
|
15880
|
+
use_external_sigma=(bool const & v) -> bool
|
15881
|
+
|
15882
|
+
An instance method.
|
15883
|
+
|
15884
|
+
*/
|
15885
|
+
SWIGINTERN VALUE
|
15886
|
+
_wrap_SolverOptionsCommon_use_external_sigmae___(int argc, VALUE *argv, VALUE self) {
|
15887
|
+
GPS_SolverOptions_Common< double > *arg1 = (GPS_SolverOptions_Common< double > *) 0 ;
|
15888
|
+
bool *arg2 = 0 ;
|
15889
|
+
void *argp1 = 0 ;
|
15890
|
+
int res1 = 0 ;
|
15891
|
+
bool temp2 ;
|
15892
|
+
bool val2 ;
|
15893
|
+
int ecode2 = 0 ;
|
15894
|
+
bool result;
|
15895
|
+
VALUE vresult = Qnil;
|
15896
|
+
|
15897
|
+
if ((argc < 1) || (argc > 1)) {
|
15898
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
15899
|
+
}
|
15900
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, 0 | 0 );
|
15901
|
+
if (!SWIG_IsOK(res1)) {
|
15902
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SolverOptions_Common< double > *","set_use_external_sigma", 1, self ));
|
15903
|
+
}
|
15904
|
+
arg1 = reinterpret_cast< GPS_SolverOptions_Common< double > * >(argp1);
|
15905
|
+
ecode2 = SWIG_AsVal_bool(argv[0], &val2);
|
15906
|
+
if (!SWIG_IsOK(ecode2)) {
|
15907
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","set_use_external_sigma", 2, argv[0] ));
|
15908
|
+
}
|
15909
|
+
temp2 = static_cast< bool >(val2);
|
15910
|
+
arg2 = &temp2;
|
15911
|
+
result = (bool)GPS_SolverOptions_Common_Sl_double_Sg__set_use_external_sigma(arg1,(bool const &)*arg2);
|
15912
|
+
vresult = SWIG_From_bool(static_cast< bool >(result));
|
15913
|
+
return vresult;
|
15914
|
+
fail:
|
15915
|
+
return Qnil;
|
15916
|
+
}
|
15917
|
+
|
15918
|
+
|
15919
|
+
/*
|
15920
|
+
Document-method: GPS_PVT::GPS::SolverOptionsCommon.use_external_sigma
|
15921
|
+
|
15922
|
+
call-seq:
|
15923
|
+
use_external_sigma -> bool const &
|
15924
|
+
|
15925
|
+
An instance method.
|
15926
|
+
|
15927
|
+
*/
|
15928
|
+
SWIGINTERN VALUE
|
15929
|
+
_wrap_SolverOptionsCommon_use_external_sigma(int argc, VALUE *argv, VALUE self) {
|
15930
|
+
GPS_SolverOptions_Common< double > *arg1 = (GPS_SolverOptions_Common< double > *) 0 ;
|
15931
|
+
void *argp1 = 0 ;
|
15932
|
+
int res1 = 0 ;
|
15933
|
+
bool *result = 0 ;
|
15934
|
+
VALUE vresult = Qnil;
|
15935
|
+
|
15936
|
+
if ((argc < 0) || (argc > 0)) {
|
15937
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
15938
|
+
}
|
15939
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, 0 | 0 );
|
15940
|
+
if (!SWIG_IsOK(res1)) {
|
15941
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SolverOptions_Common< double > const *","get_use_external_sigma", 1, self ));
|
15942
|
+
}
|
15943
|
+
arg1 = reinterpret_cast< GPS_SolverOptions_Common< double > * >(argp1);
|
15944
|
+
result = (bool *) &GPS_SolverOptions_Common_Sl_double_Sg__get_use_external_sigma((GPS_SolverOptions_Common< double > const *)arg1);
|
15945
|
+
vresult = SWIG_From_bool(static_cast< bool >(*result));
|
15946
|
+
return vresult;
|
15947
|
+
fail:
|
15948
|
+
return Qnil;
|
15949
|
+
}
|
15950
|
+
|
15951
|
+
|
15477
15952
|
/*
|
15478
15953
|
Document-class: GPS_PVT::GPS::SolverOptions < GPS::SolverOptionsCommon
|
15479
15954
|
|
@@ -16400,6 +16875,82 @@ fail:
|
|
16400
16875
|
}
|
16401
16876
|
|
16402
16877
|
|
16878
|
+
/*
|
16879
|
+
Document-method: GPS_PVT::GPS::Ephemeris_SBAS.URA_index
|
16880
|
+
|
16881
|
+
call-seq:
|
16882
|
+
URA_index -> int
|
16883
|
+
|
16884
|
+
An instance method.
|
16885
|
+
|
16886
|
+
*/
|
16887
|
+
SWIGINTERN VALUE
|
16888
|
+
_wrap_Ephemeris_SBAS_URA_index(int argc, VALUE *argv, VALUE self) {
|
16889
|
+
SBAS_Ephemeris< double > *arg1 = (SBAS_Ephemeris< double > *) 0 ;
|
16890
|
+
void *argp1 = 0 ;
|
16891
|
+
int res1 = 0 ;
|
16892
|
+
int result;
|
16893
|
+
VALUE vresult = Qnil;
|
16894
|
+
|
16895
|
+
if ((argc < 0) || (argc > 0)) {
|
16896
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
16897
|
+
}
|
16898
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SBAS_EphemerisT_double_t, 0 | 0 );
|
16899
|
+
if (!SWIG_IsOK(res1)) {
|
16900
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_Ephemeris< double > const *","get_URA_index", 1, self ));
|
16901
|
+
}
|
16902
|
+
arg1 = reinterpret_cast< SBAS_Ephemeris< double > * >(argp1);
|
16903
|
+
result = (int)((SBAS_Ephemeris< double > const *)arg1)->get_URA_index();
|
16904
|
+
vresult = SWIG_From_int(static_cast< int >(result));
|
16905
|
+
return vresult;
|
16906
|
+
fail:
|
16907
|
+
return Qnil;
|
16908
|
+
}
|
16909
|
+
|
16910
|
+
|
16911
|
+
/*
|
16912
|
+
Document-method: GPS_PVT::GPS::Ephemeris_SBAS.URA_index=
|
16913
|
+
|
16914
|
+
call-seq:
|
16915
|
+
URA_index=(int const & idx) -> int
|
16916
|
+
|
16917
|
+
An instance method.
|
16918
|
+
|
16919
|
+
*/
|
16920
|
+
SWIGINTERN VALUE
|
16921
|
+
_wrap_Ephemeris_SBAS_URA_indexe___(int argc, VALUE *argv, VALUE self) {
|
16922
|
+
SBAS_Ephemeris< double > *arg1 = (SBAS_Ephemeris< double > *) 0 ;
|
16923
|
+
int *arg2 = 0 ;
|
16924
|
+
void *argp1 = 0 ;
|
16925
|
+
int res1 = 0 ;
|
16926
|
+
int temp2 ;
|
16927
|
+
int val2 ;
|
16928
|
+
int ecode2 = 0 ;
|
16929
|
+
int result;
|
16930
|
+
VALUE vresult = Qnil;
|
16931
|
+
|
16932
|
+
if ((argc < 1) || (argc > 1)) {
|
16933
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
16934
|
+
}
|
16935
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SBAS_EphemerisT_double_t, 0 | 0 );
|
16936
|
+
if (!SWIG_IsOK(res1)) {
|
16937
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_Ephemeris< double > *","set_URA_index", 1, self ));
|
16938
|
+
}
|
16939
|
+
arg1 = reinterpret_cast< SBAS_Ephemeris< double > * >(argp1);
|
16940
|
+
ecode2 = SWIG_AsVal_int(argv[0], &val2);
|
16941
|
+
if (!SWIG_IsOK(ecode2)) {
|
16942
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","set_URA_index", 2, argv[0] ));
|
16943
|
+
}
|
16944
|
+
temp2 = static_cast< int >(val2);
|
16945
|
+
arg2 = &temp2;
|
16946
|
+
result = (int)(arg1)->set_URA_index((int const &)*arg2);
|
16947
|
+
vresult = SWIG_From_int(static_cast< int >(result));
|
16948
|
+
return vresult;
|
16949
|
+
fail:
|
16950
|
+
return Qnil;
|
16951
|
+
}
|
16952
|
+
|
16953
|
+
|
16403
16954
|
/*
|
16404
16955
|
Document-method: GPS_PVT::GPS::Ephemeris_SBAS.svid=
|
16405
16956
|
|
@@ -20289,6 +20840,158 @@ fail:
|
|
20289
20840
|
}
|
20290
20841
|
|
20291
20842
|
|
20843
|
+
/*
|
20844
|
+
Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.F_T_index
|
20845
|
+
|
20846
|
+
call-seq:
|
20847
|
+
F_T_index -> unsigned char
|
20848
|
+
|
20849
|
+
An instance method.
|
20850
|
+
|
20851
|
+
*/
|
20852
|
+
SWIGINTERN VALUE
|
20853
|
+
_wrap_Ephemeris_GLONASS_F_T_index(int argc, VALUE *argv, VALUE self) {
|
20854
|
+
GLONASS_Ephemeris< double > *arg1 = (GLONASS_Ephemeris< double > *) 0 ;
|
20855
|
+
void *argp1 = 0 ;
|
20856
|
+
int res1 = 0 ;
|
20857
|
+
unsigned char result;
|
20858
|
+
VALUE vresult = Qnil;
|
20859
|
+
|
20860
|
+
if ((argc < 0) || (argc > 0)) {
|
20861
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
20862
|
+
}
|
20863
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLONASS_EphemerisT_double_t, 0 | 0 );
|
20864
|
+
if (!SWIG_IsOK(res1)) {
|
20865
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GLONASS_Ephemeris< double > const *","get_F_T_index", 1, self ));
|
20866
|
+
}
|
20867
|
+
arg1 = reinterpret_cast< GLONASS_Ephemeris< double > * >(argp1);
|
20868
|
+
result = (unsigned char)((GLONASS_Ephemeris< double > const *)arg1)->get_F_T_index();
|
20869
|
+
vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
|
20870
|
+
return vresult;
|
20871
|
+
fail:
|
20872
|
+
return Qnil;
|
20873
|
+
}
|
20874
|
+
|
20875
|
+
|
20876
|
+
/*
|
20877
|
+
Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.F_T_index=
|
20878
|
+
|
20879
|
+
call-seq:
|
20880
|
+
F_T_index=(unsigned char const & idx) -> unsigned char
|
20881
|
+
|
20882
|
+
An instance method.
|
20883
|
+
|
20884
|
+
*/
|
20885
|
+
SWIGINTERN VALUE
|
20886
|
+
_wrap_Ephemeris_GLONASS_F_T_indexe___(int argc, VALUE *argv, VALUE self) {
|
20887
|
+
GLONASS_Ephemeris< double > *arg1 = (GLONASS_Ephemeris< double > *) 0 ;
|
20888
|
+
unsigned char *arg2 = 0 ;
|
20889
|
+
void *argp1 = 0 ;
|
20890
|
+
int res1 = 0 ;
|
20891
|
+
unsigned char temp2 ;
|
20892
|
+
unsigned char val2 ;
|
20893
|
+
int ecode2 = 0 ;
|
20894
|
+
unsigned char result;
|
20895
|
+
VALUE vresult = Qnil;
|
20896
|
+
|
20897
|
+
if ((argc < 1) || (argc > 1)) {
|
20898
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
20899
|
+
}
|
20900
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLONASS_EphemerisT_double_t, 0 | 0 );
|
20901
|
+
if (!SWIG_IsOK(res1)) {
|
20902
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GLONASS_Ephemeris< double > *","set_F_T_index", 1, self ));
|
20903
|
+
}
|
20904
|
+
arg1 = reinterpret_cast< GLONASS_Ephemeris< double > * >(argp1);
|
20905
|
+
ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
|
20906
|
+
if (!SWIG_IsOK(ecode2)) {
|
20907
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned char","set_F_T_index", 2, argv[0] ));
|
20908
|
+
}
|
20909
|
+
temp2 = static_cast< unsigned char >(val2);
|
20910
|
+
arg2 = &temp2;
|
20911
|
+
result = (unsigned char)(arg1)->set_F_T_index((unsigned char const &)*arg2);
|
20912
|
+
vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
|
20913
|
+
return vresult;
|
20914
|
+
fail:
|
20915
|
+
return Qnil;
|
20916
|
+
}
|
20917
|
+
|
20918
|
+
|
20919
|
+
/*
|
20920
|
+
Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.P1_index
|
20921
|
+
|
20922
|
+
call-seq:
|
20923
|
+
P1_index -> unsigned char
|
20924
|
+
|
20925
|
+
An instance method.
|
20926
|
+
|
20927
|
+
*/
|
20928
|
+
SWIGINTERN VALUE
|
20929
|
+
_wrap_Ephemeris_GLONASS_P1_index(int argc, VALUE *argv, VALUE self) {
|
20930
|
+
GLONASS_Ephemeris< double > *arg1 = (GLONASS_Ephemeris< double > *) 0 ;
|
20931
|
+
void *argp1 = 0 ;
|
20932
|
+
int res1 = 0 ;
|
20933
|
+
unsigned char result;
|
20934
|
+
VALUE vresult = Qnil;
|
20935
|
+
|
20936
|
+
if ((argc < 0) || (argc > 0)) {
|
20937
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
20938
|
+
}
|
20939
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLONASS_EphemerisT_double_t, 0 | 0 );
|
20940
|
+
if (!SWIG_IsOK(res1)) {
|
20941
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GLONASS_Ephemeris< double > const *","get_P1_index", 1, self ));
|
20942
|
+
}
|
20943
|
+
arg1 = reinterpret_cast< GLONASS_Ephemeris< double > * >(argp1);
|
20944
|
+
result = (unsigned char)((GLONASS_Ephemeris< double > const *)arg1)->get_P1_index();
|
20945
|
+
vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
|
20946
|
+
return vresult;
|
20947
|
+
fail:
|
20948
|
+
return Qnil;
|
20949
|
+
}
|
20950
|
+
|
20951
|
+
|
20952
|
+
/*
|
20953
|
+
Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.P1_index=
|
20954
|
+
|
20955
|
+
call-seq:
|
20956
|
+
P1_index=(unsigned char const & idx) -> unsigned char
|
20957
|
+
|
20958
|
+
An instance method.
|
20959
|
+
|
20960
|
+
*/
|
20961
|
+
SWIGINTERN VALUE
|
20962
|
+
_wrap_Ephemeris_GLONASS_P1_indexe___(int argc, VALUE *argv, VALUE self) {
|
20963
|
+
GLONASS_Ephemeris< double > *arg1 = (GLONASS_Ephemeris< double > *) 0 ;
|
20964
|
+
unsigned char *arg2 = 0 ;
|
20965
|
+
void *argp1 = 0 ;
|
20966
|
+
int res1 = 0 ;
|
20967
|
+
unsigned char temp2 ;
|
20968
|
+
unsigned char val2 ;
|
20969
|
+
int ecode2 = 0 ;
|
20970
|
+
unsigned char result;
|
20971
|
+
VALUE vresult = Qnil;
|
20972
|
+
|
20973
|
+
if ((argc < 1) || (argc > 1)) {
|
20974
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
20975
|
+
}
|
20976
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLONASS_EphemerisT_double_t, 0 | 0 );
|
20977
|
+
if (!SWIG_IsOK(res1)) {
|
20978
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GLONASS_Ephemeris< double > *","set_P1_index", 1, self ));
|
20979
|
+
}
|
20980
|
+
arg1 = reinterpret_cast< GLONASS_Ephemeris< double > * >(argp1);
|
20981
|
+
ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
|
20982
|
+
if (!SWIG_IsOK(ecode2)) {
|
20983
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned char","set_P1_index", 2, argv[0] ));
|
20984
|
+
}
|
20985
|
+
temp2 = static_cast< unsigned char >(val2);
|
20986
|
+
arg2 = &temp2;
|
20987
|
+
result = (unsigned char)(arg1)->set_P1_index((unsigned char const &)*arg2);
|
20988
|
+
vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
|
20989
|
+
return vresult;
|
20990
|
+
fail:
|
20991
|
+
return Qnil;
|
20992
|
+
}
|
20993
|
+
|
20994
|
+
|
20292
20995
|
/*
|
20293
20996
|
Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.svid=
|
20294
20997
|
|
@@ -22709,6 +23412,72 @@ fail:
|
|
22709
23412
|
}
|
22710
23413
|
|
22711
23414
|
|
23415
|
+
/*
|
23416
|
+
Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.N_4
|
23417
|
+
|
23418
|
+
call-seq:
|
23419
|
+
N_4 -> unsigned char
|
23420
|
+
|
23421
|
+
An instance method.
|
23422
|
+
|
23423
|
+
*/
|
23424
|
+
SWIGINTERN VALUE
|
23425
|
+
_wrap_Ephemeris_GLONASS_N_4(int argc, VALUE *argv, VALUE self) {
|
23426
|
+
GLONASS_Ephemeris< double > *arg1 = (GLONASS_Ephemeris< double > *) 0 ;
|
23427
|
+
void *argp1 = 0 ;
|
23428
|
+
int res1 = 0 ;
|
23429
|
+
unsigned char result;
|
23430
|
+
VALUE vresult = Qnil;
|
23431
|
+
|
23432
|
+
if ((argc < 0) || (argc > 0)) {
|
23433
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
23434
|
+
}
|
23435
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLONASS_EphemerisT_double_t, 0 | 0 );
|
23436
|
+
if (!SWIG_IsOK(res1)) {
|
23437
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GLONASS_Ephemeris< double > const *","N_4", 1, self ));
|
23438
|
+
}
|
23439
|
+
arg1 = reinterpret_cast< GLONASS_Ephemeris< double > * >(argp1);
|
23440
|
+
result = (unsigned char)GLONASS_Ephemeris_Sl_double_Sg__N_4((GLONASS_Ephemeris< double > const *)arg1);
|
23441
|
+
vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
|
23442
|
+
return vresult;
|
23443
|
+
fail:
|
23444
|
+
return Qnil;
|
23445
|
+
}
|
23446
|
+
|
23447
|
+
|
23448
|
+
/*
|
23449
|
+
Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.NA
|
23450
|
+
|
23451
|
+
call-seq:
|
23452
|
+
NA -> unsigned short
|
23453
|
+
|
23454
|
+
An instance method.
|
23455
|
+
|
23456
|
+
*/
|
23457
|
+
SWIGINTERN VALUE
|
23458
|
+
_wrap_Ephemeris_GLONASS_NA(int argc, VALUE *argv, VALUE self) {
|
23459
|
+
GLONASS_Ephemeris< double > *arg1 = (GLONASS_Ephemeris< double > *) 0 ;
|
23460
|
+
void *argp1 = 0 ;
|
23461
|
+
int res1 = 0 ;
|
23462
|
+
unsigned short result;
|
23463
|
+
VALUE vresult = Qnil;
|
23464
|
+
|
23465
|
+
if ((argc < 0) || (argc > 0)) {
|
23466
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
23467
|
+
}
|
23468
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLONASS_EphemerisT_double_t, 0 | 0 );
|
23469
|
+
if (!SWIG_IsOK(res1)) {
|
23470
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GLONASS_Ephemeris< double > const *","NA", 1, self ));
|
23471
|
+
}
|
23472
|
+
arg1 = reinterpret_cast< GLONASS_Ephemeris< double > * >(argp1);
|
23473
|
+
result = (unsigned short)GLONASS_Ephemeris_Sl_double_Sg__NA((GLONASS_Ephemeris< double > const *)arg1);
|
23474
|
+
vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
|
23475
|
+
return vresult;
|
23476
|
+
fail:
|
23477
|
+
return Qnil;
|
23478
|
+
}
|
23479
|
+
|
23480
|
+
|
22712
23481
|
/*
|
22713
23482
|
Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.frequency_L1
|
22714
23483
|
|
@@ -25147,6 +25916,8 @@ SWIGEXPORT void Init_GPS(void) {
|
|
25147
25916
|
rb_define_method(SwigClassEphemeris.klass, "valid?", VALUEFUNC(_wrap_Ephemeris_validq___), -1);
|
25148
25917
|
rb_define_method(SwigClassEphemeris.klass, "t_clock", VALUEFUNC(_wrap_Ephemeris_t_clock), -1);
|
25149
25918
|
rb_define_method(SwigClassEphemeris.klass, "t_ephemeris", VALUEFUNC(_wrap_Ephemeris_t_ephemeris), -1);
|
25919
|
+
rb_define_method(SwigClassEphemeris.klass, "URA_index", VALUEFUNC(_wrap_Ephemeris_URA_index), -1);
|
25920
|
+
rb_define_method(SwigClassEphemeris.klass, "URA_index=", VALUEFUNC(_wrap_Ephemeris_URA_indexe___), -1);
|
25150
25921
|
rb_define_method(SwigClassEphemeris.klass, "svid=", VALUEFUNC(_wrap_Ephemeris_svide___), -1);
|
25151
25922
|
rb_define_method(SwigClassEphemeris.klass, "svid", VALUEFUNC(_wrap_Ephemeris_svid), -1);
|
25152
25923
|
rb_define_method(SwigClassEphemeris.klass, "WN=", VALUEFUNC(_wrap_Ephemeris_WNe___), -1);
|
@@ -25238,6 +26009,10 @@ SWIGEXPORT void Init_GPS(void) {
|
|
25238
26009
|
rb_define_method(SwigClassPVT.klass, "hdop", VALUEFUNC(_wrap_PVT_hdop), -1);
|
25239
26010
|
rb_define_method(SwigClassPVT.klass, "vdop", VALUEFUNC(_wrap_PVT_vdop), -1);
|
25240
26011
|
rb_define_method(SwigClassPVT.klass, "tdop", VALUEFUNC(_wrap_PVT_tdop), -1);
|
26012
|
+
rb_define_method(SwigClassPVT.klass, "hsigma", VALUEFUNC(_wrap_PVT_hsigma), -1);
|
26013
|
+
rb_define_method(SwigClassPVT.klass, "vsigma", VALUEFUNC(_wrap_PVT_vsigma), -1);
|
26014
|
+
rb_define_method(SwigClassPVT.klass, "tsigma", VALUEFUNC(_wrap_PVT_tsigma), -1);
|
26015
|
+
rb_define_method(SwigClassPVT.klass, "vel_sigma", VALUEFUNC(_wrap_PVT_vel_sigma), -1);
|
25241
26016
|
rb_define_method(SwigClassPVT.klass, "used_satellites", VALUEFUNC(_wrap_PVT_used_satellites), -1);
|
25242
26017
|
rb_define_method(SwigClassPVT.klass, "used_satellite_list", VALUEFUNC(_wrap_PVT_used_satellite_list), -1);
|
25243
26018
|
rb_define_method(SwigClassPVT.klass, "position_solved?", VALUEFUNC(_wrap_PVT_position_solvedq___), -1);
|
@@ -25313,6 +26088,8 @@ SWIGEXPORT void Init_GPS(void) {
|
|
25313
26088
|
rb_define_method(SwigClassSolverOptionsCommon.klass, "elevation_mask", VALUEFUNC(_wrap_SolverOptionsCommon_elevation_mask), -1);
|
25314
26089
|
rb_define_method(SwigClassSolverOptionsCommon.klass, "residual_mask=", VALUEFUNC(_wrap_SolverOptionsCommon_residual_maske___), -1);
|
25315
26090
|
rb_define_method(SwigClassSolverOptionsCommon.klass, "residual_mask", VALUEFUNC(_wrap_SolverOptionsCommon_residual_mask), -1);
|
26091
|
+
rb_define_method(SwigClassSolverOptionsCommon.klass, "use_external_sigma=", VALUEFUNC(_wrap_SolverOptionsCommon_use_external_sigmae___), -1);
|
26092
|
+
rb_define_method(SwigClassSolverOptionsCommon.klass, "use_external_sigma", VALUEFUNC(_wrap_SolverOptionsCommon_use_external_sigma), -1);
|
25316
26093
|
SwigClassSolverOptionsCommon.mark = 0;
|
25317
26094
|
SwigClassSolverOptionsCommon.destroy = (void (*)(void *)) free_GPS_SolverOptions_Common_Sl_double_Sg_;
|
25318
26095
|
SwigClassSolverOptionsCommon.trackObjects = 0;
|
@@ -25356,6 +26133,8 @@ SWIGEXPORT void Init_GPS(void) {
|
|
25356
26133
|
rb_define_method(SwigClassEphemeris_SBAS.klass, "initialize", VALUEFUNC(_wrap_new_Ephemeris_SBAS), -1);
|
25357
26134
|
rb_define_method(SwigClassEphemeris_SBAS.klass, "valid?", VALUEFUNC(_wrap_Ephemeris_SBAS_validq___), -1);
|
25358
26135
|
rb_define_method(SwigClassEphemeris_SBAS.klass, "t_applicable", VALUEFUNC(_wrap_Ephemeris_SBAS_t_applicable), -1);
|
26136
|
+
rb_define_method(SwigClassEphemeris_SBAS.klass, "URA_index", VALUEFUNC(_wrap_Ephemeris_SBAS_URA_index), -1);
|
26137
|
+
rb_define_method(SwigClassEphemeris_SBAS.klass, "URA_index=", VALUEFUNC(_wrap_Ephemeris_SBAS_URA_indexe___), -1);
|
25359
26138
|
rb_define_method(SwigClassEphemeris_SBAS.klass, "svid=", VALUEFUNC(_wrap_Ephemeris_SBAS_svide___), -1);
|
25360
26139
|
rb_define_method(SwigClassEphemeris_SBAS.klass, "svid", VALUEFUNC(_wrap_Ephemeris_SBAS_svid), -1);
|
25361
26140
|
rb_define_method(SwigClassEphemeris_SBAS.klass, "WN=", VALUEFUNC(_wrap_Ephemeris_SBAS_WNe___), -1);
|
@@ -25477,6 +26256,10 @@ SWIGEXPORT void Init_GPS(void) {
|
|
25477
26256
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "in_range?", VALUEFUNC(_wrap_Ephemeris_GLONASS_in_rangeq___), -1);
|
25478
26257
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "valid?", VALUEFUNC(_wrap_Ephemeris_GLONASS_validq___), -1);
|
25479
26258
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "rehash", VALUEFUNC(_wrap_Ephemeris_GLONASS_rehash), -1);
|
26259
|
+
rb_define_method(SwigClassEphemeris_GLONASS.klass, "F_T_index", VALUEFUNC(_wrap_Ephemeris_GLONASS_F_T_index), -1);
|
26260
|
+
rb_define_method(SwigClassEphemeris_GLONASS.klass, "F_T_index=", VALUEFUNC(_wrap_Ephemeris_GLONASS_F_T_indexe___), -1);
|
26261
|
+
rb_define_method(SwigClassEphemeris_GLONASS.klass, "P1_index", VALUEFUNC(_wrap_Ephemeris_GLONASS_P1_index), -1);
|
26262
|
+
rb_define_method(SwigClassEphemeris_GLONASS.klass, "P1_index=", VALUEFUNC(_wrap_Ephemeris_GLONASS_P1_indexe___), -1);
|
25480
26263
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "svid=", VALUEFUNC(_wrap_Ephemeris_GLONASS_svide___), -1);
|
25481
26264
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "svid", VALUEFUNC(_wrap_Ephemeris_GLONASS_svid), -1);
|
25482
26265
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "freq_ch=", VALUEFUNC(_wrap_Ephemeris_GLONASS_freq_che___), -1);
|
@@ -25538,6 +26321,8 @@ SWIGEXPORT void Init_GPS(void) {
|
|
25538
26321
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "day_of_year=", VALUEFUNC(_wrap_Ephemeris_GLONASS_day_of_yeare___), -1);
|
25539
26322
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "day_of_year", VALUEFUNC(_wrap_Ephemeris_GLONASS_day_of_year), -1);
|
25540
26323
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "set_date", VALUEFUNC(_wrap_Ephemeris_GLONASS_set_date), -1);
|
26324
|
+
rb_define_method(SwigClassEphemeris_GLONASS.klass, "N_4", VALUEFUNC(_wrap_Ephemeris_GLONASS_N_4), -1);
|
26325
|
+
rb_define_method(SwigClassEphemeris_GLONASS.klass, "NA", VALUEFUNC(_wrap_Ephemeris_GLONASS_NA), -1);
|
25541
26326
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "frequency_L1", VALUEFUNC(_wrap_Ephemeris_GLONASS_frequency_L1), -1);
|
25542
26327
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "frequency_L2", VALUEFUNC(_wrap_Ephemeris_GLONASS_frequency_L2), -1);
|
25543
26328
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "base_time", VALUEFUNC(_wrap_Ephemeris_GLONASS_base_time), -1);
|