gps_pvt 0.7.2 → 0.8.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 +1 -1
- data/Rakefile +1 -0
- data/exe/gps_pvt +3 -18
- data/exe/to_ubx +103 -8
- data/ext/gps_pvt/GPS/GPS_wrap.cxx +1136 -65
- data/ext/ninja-scan-light/tool/navigation/GLONASS.h +137 -9
- data/ext/ninja-scan-light/tool/navigation/GPS.h +301 -50
- data/ext/ninja-scan-light/tool/navigation/QZSS.h +48 -15
- data/ext/ninja-scan-light/tool/navigation/SBAS.h +106 -4
- data/ext/ninja-scan-light/tool/param/bit_array.h +53 -16
- data/ext/ninja-scan-light/tool/swig/GPS.i +228 -24
- data/ext/ninja-scan-light/tool/swig/spec/GPS_spec.rb +61 -0
- data/ext/ninja-scan-light/tool/util/bit_counter.h +84 -0
- data/gps_pvt.gemspec +1 -0
- data/lib/gps_pvt/receiver/extension.rb +51 -0
- data/lib/gps_pvt/receiver.rb +79 -56
- data/lib/gps_pvt/util.rb +33 -1
- data/lib/gps_pvt/version.rb +1 -1
- metadata +18 -2
@@ -1913,9 +1913,10 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
|
|
1913
1913
|
#define SWIGTYPE_p_u32_t swig_types[63]
|
1914
1914
|
#define SWIGTYPE_p_u8_t swig_types[64]
|
1915
1915
|
#define SWIGTYPE_p_uint_t swig_types[65]
|
1916
|
-
#define
|
1917
|
-
|
1918
|
-
static
|
1916
|
+
#define SWIGTYPE_p_unsigned_int swig_types[66]
|
1917
|
+
#define SWIGTYPE_p_xyz_t swig_types[67]
|
1918
|
+
static swig_type_info *swig_types[69];
|
1919
|
+
static swig_module_info swig_module = {swig_types, 68, 0, 0, 0, 0};
|
1919
1920
|
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
|
1920
1921
|
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
|
1921
1922
|
|
@@ -2360,6 +2361,11 @@ struct GPS_Ephemeris : public GPS_SpaceNode<FloatT>::SatelliteProperties::Epheme
|
|
2360
2361
|
|| (this->iode != this->iode_subframe3)
|
2361
2362
|
|| ((this->iodc & 0xFF) != this->iode));
|
2362
2363
|
}
|
2364
|
+
bool is_valid(const GPS_Time<FloatT> &t) const {
|
2365
|
+
return is_consistent() && GPS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris::is_valid(t);
|
2366
|
+
}
|
2367
|
+
GPS_Time<FloatT> t_clock() const {return GPS_Time<FloatT>(this->WN, this->t_oc);}
|
2368
|
+
GPS_Time<FloatT> t_ephemeris() const {return GPS_Time<FloatT>(this->WN, this->t_oe);}
|
2363
2369
|
GPS_Ephemeris() : GPS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris() {
|
2364
2370
|
invalidate();
|
2365
2371
|
}
|
@@ -2381,6 +2387,10 @@ struct SBAS_Ephemeris : public SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephe
|
|
2381
2387
|
SBAS_Ephemeris() : SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris() {}
|
2382
2388
|
SBAS_Ephemeris(const typename SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris &eph)
|
2383
2389
|
: SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris(eph) {}
|
2390
|
+
bool is_valid(const GPS_Time<FloatT> &t) const {
|
2391
|
+
return SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris::is_valid(t);
|
2392
|
+
}
|
2393
|
+
GPS_Time<FloatT> t_applicable() const {return GPS_Time<FloatT>(this->WN, this->t_0);}
|
2384
2394
|
};
|
2385
2395
|
|
2386
2396
|
|
@@ -2397,6 +2407,9 @@ struct GLONASS_Ephemeris
|
|
2397
2407
|
bool is_consistent() const {
|
2398
2408
|
return has_string == 0x1F;
|
2399
2409
|
}
|
2410
|
+
bool is_valid(const GPS_Time<FloatT> &t) const {
|
2411
|
+
return is_consistent() && eph_t::is_valid(t);
|
2412
|
+
}
|
2400
2413
|
GLONASS_Ephemeris() : eph_t() {
|
2401
2414
|
invalidate();
|
2402
2415
|
}
|
@@ -2600,6 +2613,42 @@ struct GPS_RangeCorrector
|
|
2600
2613
|
};
|
2601
2614
|
|
2602
2615
|
|
2616
|
+
template <class BaseT, class HookT>
|
2617
|
+
struct HookableSolver : public BaseT {
|
2618
|
+
typedef BaseT base_t;
|
2619
|
+
HookT *hook;
|
2620
|
+
HookableSolver(const BaseT &base) : BaseT(base), hook(NULL) {}
|
2621
|
+
virtual typename base_t::relative_property_t relative_property(
|
2622
|
+
const typename base_t::prn_t &prn,
|
2623
|
+
const typename base_t::measurement_t::mapped_type &measurement,
|
2624
|
+
const typename base_t::float_t &receiver_error,
|
2625
|
+
const typename base_t::gps_time_t &time_arrival,
|
2626
|
+
const typename base_t::pos_t &usr_pos,
|
2627
|
+
const typename base_t::xyz_t &usr_vel) const {
|
2628
|
+
typename base_t::relative_property_t res(
|
2629
|
+
base_t::relative_property(
|
2630
|
+
prn, measurement, receiver_error, time_arrival,
|
2631
|
+
usr_pos, usr_vel));
|
2632
|
+
if(hook){
|
2633
|
+
res = hook->relative_property(
|
2634
|
+
prn, measurement, receiver_error, time_arrival,
|
2635
|
+
usr_pos, usr_vel,
|
2636
|
+
res);
|
2637
|
+
}
|
2638
|
+
return res;
|
2639
|
+
}
|
2640
|
+
virtual typename base_t::satellite_t select_satellite(
|
2641
|
+
const typename base_t::prn_t &prn,
|
2642
|
+
const typename base_t::gps_time_t &time) const {
|
2643
|
+
typename base_t::satellite_t res(base_t::select_satellite(prn, time));
|
2644
|
+
if(hook){
|
2645
|
+
res = hook->select_satellite(prn, time, res);
|
2646
|
+
}
|
2647
|
+
return res;
|
2648
|
+
}
|
2649
|
+
};
|
2650
|
+
|
2651
|
+
|
2603
2652
|
template <class FloatT>
|
2604
2653
|
struct GPS_Solver
|
2605
2654
|
: public GPS_Solver_RAIM_LSR<FloatT,
|
@@ -2610,7 +2659,7 @@ struct GPS_Solver
|
|
2610
2659
|
struct gps_t {
|
2611
2660
|
GPS_SpaceNode<FloatT> space_node;
|
2612
2661
|
GPS_SolverOptions<FloatT> options;
|
2613
|
-
GPS_SinglePositioning<FloatT> solver;
|
2662
|
+
HookableSolver<GPS_SinglePositioning<FloatT>, GPS_Solver<FloatT> > solver;
|
2614
2663
|
struct ephemeris_proxy_t {
|
2615
2664
|
struct item_t {
|
2616
2665
|
const void *impl;
|
@@ -2632,19 +2681,19 @@ struct GPS_Solver
|
|
2632
2681
|
solver.satellites.impl_select = forward;
|
2633
2682
|
}
|
2634
2683
|
} ephemeris_proxy;
|
2635
|
-
gps_t() : space_node(), options(), solver(space_node), ephemeris_proxy(solver) {}
|
2684
|
+
gps_t() : space_node(), options(), solver(GPS_SinglePositioning<FloatT>(space_node)), ephemeris_proxy(solver) {}
|
2636
2685
|
} gps;
|
2637
2686
|
struct sbas_t {
|
2638
2687
|
SBAS_SpaceNode<FloatT> space_node;
|
2639
2688
|
SBAS_SolverOptions<FloatT> options;
|
2640
|
-
SBAS_SinglePositioning<FloatT> solver;
|
2641
|
-
sbas_t() : space_node(), options(), solver(space_node) {}
|
2689
|
+
HookableSolver<SBAS_SinglePositioning<FloatT>, GPS_Solver<FloatT> > solver;
|
2690
|
+
sbas_t() : space_node(), options(), solver(SBAS_SinglePositioning<FloatT>(space_node)) {}
|
2642
2691
|
} sbas;
|
2643
2692
|
struct glonass_t {
|
2644
2693
|
GLONASS_SpaceNode<FloatT> space_node;
|
2645
2694
|
GLONASS_SolverOptions<FloatT> options;
|
2646
|
-
GLONASS_SinglePositioning<FloatT> solver;
|
2647
|
-
glonass_t() : space_node(), options(), solver(space_node) {}
|
2695
|
+
HookableSolver<GLONASS_SinglePositioning<FloatT>, GPS_Solver<FloatT> > solver;
|
2696
|
+
glonass_t() : space_node(), options(), solver(GLONASS_SinglePositioning<FloatT>(space_node)) {}
|
2648
2697
|
} glonass;
|
2649
2698
|
VALUE hooks;
|
2650
2699
|
typedef std::vector<GPS_RangeCorrector<FloatT> > user_correctors_t;
|
@@ -2679,6 +2728,9 @@ struct GPS_Solver
|
|
2679
2728
|
= sbas.solver.tropospheric_correction
|
2680
2729
|
= glonass.solver.tropospheric_correction
|
2681
2730
|
= tropospheric;
|
2731
|
+
gps.solver.hook = this;
|
2732
|
+
sbas.solver.hook = this;
|
2733
|
+
glonass.solver.hook = this;
|
2682
2734
|
}
|
2683
2735
|
GPS_SpaceNode<FloatT> &gps_space_node() {return gps.space_node;}
|
2684
2736
|
GPS_SolverOptions<FloatT> &gps_options() {return gps.options;}
|
@@ -2686,28 +2738,44 @@ struct GPS_Solver
|
|
2686
2738
|
SBAS_SolverOptions<FloatT> &sbas_options() {return sbas.options;}
|
2687
2739
|
GLONASS_SpaceNode<FloatT> &glonass_space_node() {return glonass.space_node;}
|
2688
2740
|
GLONASS_SolverOptions<FloatT> &glonass_options() {return glonass.options;}
|
2689
|
-
const base_t &
|
2741
|
+
const base_t &select(
|
2690
2742
|
const typename base_t::prn_t &prn) const {
|
2691
2743
|
if(prn > 0 && prn <= 32){return gps.solver;}
|
2692
2744
|
if(prn >= 120 && prn <= 158){return sbas.solver;}
|
2693
2745
|
if(prn > 192 && prn <= 202){return gps.solver;}
|
2694
2746
|
if(prn > 0x100 && prn <= (0x100 + 24)){return glonass.solver;}
|
2695
|
-
|
2696
|
-
// => relative_property() => select_solver()
|
2697
|
-
// For not supported satellite, call loop prevention is required.
|
2698
|
-
static const base_t dummy;
|
2699
|
-
return dummy;
|
2747
|
+
return *this;
|
2700
2748
|
}
|
2749
|
+
// proxy of virtual functions
|
2750
|
+
typename base_t::relative_property_t relative_property(
|
2751
|
+
const typename base_t::prn_t &prn,
|
2752
|
+
const typename base_t::measurement_t::mapped_type &measurement,
|
2753
|
+
const typename base_t::float_t &receiver_error,
|
2754
|
+
const typename base_t::gps_time_t &time_arrival,
|
2755
|
+
const typename base_t::pos_t &usr_pos,
|
2756
|
+
const typename base_t::xyz_t &usr_vel,
|
2757
|
+
const typename base_t::relative_property_t &orig) const;
|
2701
2758
|
virtual typename base_t::relative_property_t relative_property(
|
2702
2759
|
const typename base_t::prn_t &prn,
|
2703
2760
|
const typename base_t::measurement_t::mapped_type &measurement,
|
2704
2761
|
const typename base_t::float_t &receiver_error,
|
2705
2762
|
const typename base_t::gps_time_t &time_arrival,
|
2706
2763
|
const typename base_t::pos_t &usr_pos,
|
2707
|
-
const typename base_t::xyz_t &usr_vel) const
|
2764
|
+
const typename base_t::xyz_t &usr_vel) const {
|
2765
|
+
return relative_property(
|
2766
|
+
prn, measurement, receiver_error, time_arrival, usr_pos, usr_vel,
|
2767
|
+
super_t::relative_property(
|
2768
|
+
prn, measurement, receiver_error, time_arrival, usr_pos, usr_vel));
|
2769
|
+
}
|
2770
|
+
typename base_t::satellite_t select_satellite(
|
2771
|
+
const typename base_t::prn_t &prn,
|
2772
|
+
const typename base_t::gps_time_t &time,
|
2773
|
+
const typename base_t::satellite_t &orig) const;
|
2708
2774
|
virtual typename base_t::satellite_t select_satellite(
|
2709
2775
|
const typename base_t::prn_t &prn,
|
2710
|
-
const typename base_t::gps_time_t &time) const
|
2776
|
+
const typename base_t::gps_time_t &time) const {
|
2777
|
+
return select_satellite(prn, time, super_t::select_satellite(prn, time));
|
2778
|
+
}
|
2711
2779
|
virtual bool update_position_solution(
|
2712
2780
|
const typename base_t::geometric_matrices_t &geomat,
|
2713
2781
|
typename base_t::user_pvt_t &res) const;
|
@@ -3565,6 +3633,13 @@ SWIGINTERN GPS_Ionospheric_UTC_Parameters< double > GPS_Ionospheric_UTC_Paramete
|
|
3565
3633
|
(typename GPS_SpaceNode<double>::Ionospheric_UTC_Parameters &)res = raw;
|
3566
3634
|
return res;
|
3567
3635
|
}
|
3636
|
+
SWIGINTERN void GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__dump(GPS_Ionospheric_UTC_Parameters< double > *self,unsigned int buf_brdc[10],GPS_Time< double > const &t){
|
3637
|
+
typedef typename GPS_SpaceNode<double>
|
3638
|
+
::BroadcastedMessage<unsigned int, 30> dump_t;
|
3639
|
+
dump_t::how_set(buf_brdc, t);
|
3640
|
+
GPS_SpaceNode<double>::Ionospheric_UTC_Parameters::raw_t raw;
|
3641
|
+
(raw = *self).dump<2, 0>(buf_brdc);
|
3642
|
+
}
|
3568
3643
|
SWIGINTERN unsigned int GPS_Ephemeris_Sl_double_Sg__set_svid(GPS_Ephemeris< double > *self,unsigned int const &v){
|
3569
3644
|
return self->svid = v;
|
3570
3645
|
}
|
@@ -3577,10 +3652,10 @@ SWIGINTERN unsigned int GPS_Ephemeris_Sl_double_Sg__set_WN(GPS_Ephemeris< double
|
|
3577
3652
|
SWIGINTERN unsigned int const &GPS_Ephemeris_Sl_double_Sg__get_WN(GPS_Ephemeris< double > const *self){
|
3578
3653
|
return self->WN;
|
3579
3654
|
}
|
3580
|
-
SWIGINTERN
|
3655
|
+
SWIGINTERN double GPS_Ephemeris_Sl_double_Sg__set_URA(GPS_Ephemeris< double > *self,double const &v){
|
3581
3656
|
return self->URA = v;
|
3582
3657
|
}
|
3583
|
-
SWIGINTERN
|
3658
|
+
SWIGINTERN double const &GPS_Ephemeris_Sl_double_Sg__get_URA(GPS_Ephemeris< double > const *self){
|
3584
3659
|
return self->URA;
|
3585
3660
|
}
|
3586
3661
|
SWIGINTERN unsigned int GPS_Ephemeris_Sl_double_Sg__set_SV_health(GPS_Ephemeris< double > *self,unsigned int const &v){
|
@@ -3783,6 +3858,62 @@ SWIGINTERN void GPS_Ephemeris_Sl_double_Sg__parse(GPS_Ephemeris< double > *self,
|
|
3783
3858
|
break;
|
3784
3859
|
}
|
3785
3860
|
}
|
3861
|
+
SWIGINTERN void GPS_Ephemeris_Sl_double_Sg__dump(GPS_Ephemeris< double > *self,unsigned int buf_sf1[10],unsigned int buf_sf2[10],unsigned int buf_sf3[10],GPS_Time< double > const &t){
|
3862
|
+
typedef typename GPS_SpaceNode<double>
|
3863
|
+
::BroadcastedMessage<unsigned int, 30> dump_t;
|
3864
|
+
GPS_SpaceNode<double>::SatelliteProperties::Ephemeris::raw_t raw;
|
3865
|
+
raw = *self;
|
3866
|
+
unsigned int *buf[10] = {buf_sf1, buf_sf2, buf_sf3};
|
3867
|
+
for(int i(0); i < 3; ++i){
|
3868
|
+
dump_t::how_set(buf[i], t);
|
3869
|
+
raw.dump<2, 0>(buf[i], i + 1);
|
3870
|
+
}
|
3871
|
+
}
|
3872
|
+
SWIGINTERN int GPS_Ephemeris_Sl_double_Sg__parse_almanac(GPS_Ephemeris< double > *self,unsigned int const buf[10]){
|
3873
|
+
typedef GPS_SpaceNode<double>::BroadcastedMessage<unsigned int, 30> parse_t;
|
3874
|
+
switch(parse_t::subframe_id(buf)){
|
3875
|
+
case 4:
|
3876
|
+
case 5:
|
3877
|
+
break;
|
3878
|
+
default: return -1;
|
3879
|
+
}
|
3880
|
+
typedef GPS_SpaceNode<double>::SatelliteProperties::Almanac almanac_t;
|
3881
|
+
almanac_t::raw_t raw;
|
3882
|
+
switch(parse_t::data_id(buf)){
|
3883
|
+
case 1: // GPS
|
3884
|
+
raw.update<2, 0>(buf);
|
3885
|
+
if((raw.svid < 1) || (raw.svid > 32)){return -1;}
|
3886
|
+
break;
|
3887
|
+
case 3: // QZSS
|
3888
|
+
reinterpret_cast<QZSS_SpaceNode<double>::SatelliteProperties::Almanac::raw_t &>(raw)
|
3889
|
+
.update<2, 0>(buf);
|
3890
|
+
if((raw.svid < 193) || (raw.svid > 202)){return -1;}
|
3891
|
+
break;
|
3892
|
+
default:
|
3893
|
+
return -1;
|
3894
|
+
}
|
3895
|
+
almanac_t almanac;
|
3896
|
+
*self = (GPS_SpaceNode<double>::SatelliteProperties::Ephemeris)(almanac = raw);
|
3897
|
+
return self->svid;
|
3898
|
+
}
|
3899
|
+
SWIGINTERN void GPS_Ephemeris_Sl_double_Sg__dump_almanac__SWIG_0(GPS_Ephemeris< double > *self,unsigned int buf_brdc[10],GPS_Time< double > const &t,unsigned int const &qzss_subframe=0){
|
3900
|
+
typedef typename GPS_SpaceNode<double>
|
3901
|
+
::BroadcastedMessage<unsigned int, 30> dump_t;
|
3902
|
+
dump_t::how_set(buf_brdc, t);
|
3903
|
+
typedef GPS_SpaceNode<double>::SatelliteProperties::Almanac almanac_t;
|
3904
|
+
almanac_t almanac;
|
3905
|
+
almanac_t::raw_t raw;
|
3906
|
+
raw = (almanac = *self);
|
3907
|
+
switch(qzss_subframe){
|
3908
|
+
case 4:
|
3909
|
+
case 5:
|
3910
|
+
reinterpret_cast<QZSS_SpaceNode<double>::SatelliteProperties::Almanac::raw_t &>(raw)
|
3911
|
+
.dump<2, 0>(buf_brdc, qzss_subframe);
|
3912
|
+
break;
|
3913
|
+
default:
|
3914
|
+
raw.dump<2, 0>(buf_brdc);
|
3915
|
+
}
|
3916
|
+
}
|
3786
3917
|
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){
|
3787
3918
|
typename GPS_SpaceNode<double>::SatelliteProperties::constellation_t pv(
|
3788
3919
|
self->constellation(t_tx, dt_transit, true));
|
@@ -3934,14 +4065,12 @@ SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_residual_mas
|
|
3934
4065
|
const GPS_Solver<double>::base_t::float_t &receiver_error,
|
3935
4066
|
const GPS_Solver<double>::base_t::gps_time_t &time_arrival,
|
3936
4067
|
const GPS_Solver<double>::base_t::pos_t &usr_pos,
|
3937
|
-
const GPS_Solver<double>::base_t::xyz_t &usr_vel
|
4068
|
+
const GPS_Solver<double>::base_t::xyz_t &usr_vel,
|
4069
|
+
const GPS_Solver<double>::base_t::relative_property_t &res_orig) const {
|
3938
4070
|
union {
|
3939
4071
|
base_t::relative_property_t prop;
|
3940
4072
|
double values[7];
|
3941
|
-
} res = {
|
3942
|
-
select_solver(prn).relative_property(
|
3943
|
-
prn, measurement, receiver_error, time_arrival,
|
3944
|
-
usr_pos, usr_vel)};
|
4073
|
+
} res = {res_orig};
|
3945
4074
|
|
3946
4075
|
do{
|
3947
4076
|
static const VALUE key(ID2SYM(rb_intern("relative_property")));
|
@@ -4021,9 +4150,9 @@ SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_residual_mas
|
|
4021
4150
|
template <>
|
4022
4151
|
GPS_Solver<double>::base_t::satellite_t GPS_Solver<double>::select_satellite(
|
4023
4152
|
const GPS_Solver<double>::base_t::prn_t &prn,
|
4024
|
-
const GPS_Solver<double>::base_t::gps_time_t &time
|
4025
|
-
|
4026
|
-
|
4153
|
+
const GPS_Solver<double>::base_t::gps_time_t &time,
|
4154
|
+
const GPS_Solver<double>::base_t::satellite_t &res_orig) const {
|
4155
|
+
GPS_Solver<double>::base_t::satellite_t res(res_orig);
|
4027
4156
|
|
4028
4157
|
if(!res.is_available()){
|
4029
4158
|
static const VALUE key(ID2SYM(rb_intern("relative_property")));
|
@@ -4280,6 +4409,12 @@ SWIGINTERN double SBAS_Ephemeris_Sl_double_Sg__set_a_Gf1(SBAS_Ephemeris< double
|
|
4280
4409
|
SWIGINTERN double const &SBAS_Ephemeris_Sl_double_Sg__get_a_Gf1(SBAS_Ephemeris< double > const *self){
|
4281
4410
|
return self->a_Gf1;
|
4282
4411
|
}
|
4412
|
+
SWIGINTERN void SBAS_Ephemeris_Sl_double_Sg__dump__SWIG_0(SBAS_Ephemeris< double > *self,unsigned int buf_brdc[8],unsigned int const &preamble_idx=0){
|
4413
|
+
SBAS_SpaceNode<double>::DataBlock::preamble_set2(buf_brdc, preamble_idx);
|
4414
|
+
SBAS_SpaceNode<double>::SatelliteProperties::Ephemeris::raw_t raw;
|
4415
|
+
(raw = *self).dump(buf_brdc);
|
4416
|
+
SBAS_SpaceNode<double>::DataBlock::parity_set(buf_brdc);
|
4417
|
+
}
|
4283
4418
|
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){
|
4284
4419
|
typename SBAS_SpaceNode<double>::SatelliteProperties::constellation_t pv(
|
4285
4420
|
self->constellation(t_tx, dt_transit, with_velocity));
|
@@ -4543,6 +4678,15 @@ SWIGINTERN bool GLONASS_Ephemeris_Sl_double_Sg__parse__SWIG_0(GLONASS_Ephemeris<
|
|
4543
4678
|
self->has_string = has_string;
|
4544
4679
|
return updated;
|
4545
4680
|
}
|
4681
|
+
SWIGINTERN void GLONASS_Ephemeris_Sl_double_Sg__dump(GLONASS_Ephemeris< double > *self,unsigned int buf_str1[3],unsigned int buf_str2[3],unsigned int buf_str3[3],unsigned int buf_str4[3],unsigned int buf_str5[3],GPS_Time< double > const &t){
|
4682
|
+
typename GLONASS_Ephemeris<double>::eph_t::raw_t raw;
|
4683
|
+
raw = *self;
|
4684
|
+
unsigned int *buf[4] = {buf_str1, buf_str2, buf_str3, buf_str4};
|
4685
|
+
for(int i(0); i < 4; ++i){
|
4686
|
+
raw.GLONASS_Ephemeris<double>::Ephemeris::raw_t::dump<0, 0>(buf[i], i + 1);
|
4687
|
+
}
|
4688
|
+
raw.GLONASS_Ephemeris<double>::TimeProperties::raw_t::dump<0, 0>(buf_str5);
|
4689
|
+
}
|
4546
4690
|
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){
|
4547
4691
|
typename GPS_SpaceNode<double>::SatelliteProperties::constellation_t pv(
|
4548
4692
|
self->constellation(t_tx, dt_transit));
|
@@ -10872,6 +11016,67 @@ fail:
|
|
10872
11016
|
}
|
10873
11017
|
|
10874
11018
|
|
11019
|
+
/*
|
11020
|
+
Document-method: GPS_PVT::GPS::Ionospheric_UTC_Parameters.dump
|
11021
|
+
|
11022
|
+
call-seq:
|
11023
|
+
dump(Time t)
|
11024
|
+
|
11025
|
+
An instance method.
|
11026
|
+
|
11027
|
+
*/
|
11028
|
+
SWIGINTERN VALUE
|
11029
|
+
_wrap_Ionospheric_UTC_Parameters_dump(int argc, VALUE *argv, VALUE self) {
|
11030
|
+
GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< double > *) 0 ;
|
11031
|
+
unsigned int *arg2 ;
|
11032
|
+
GPS_Time< double > *arg3 = 0 ;
|
11033
|
+
void *argp1 = 0 ;
|
11034
|
+
int res1 = 0 ;
|
11035
|
+
unsigned int temp2[10] = {
|
11036
|
+
0
|
11037
|
+
} ;
|
11038
|
+
void *argp3 ;
|
11039
|
+
int res3 = 0 ;
|
11040
|
+
VALUE vresult = Qnil;
|
11041
|
+
|
11042
|
+
arg2 = temp2;
|
11043
|
+
if ((argc < 1) || (argc > 1)) {
|
11044
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
11045
|
+
}
|
11046
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_Ionospheric_UTC_ParametersT_double_t, 0 | 0 );
|
11047
|
+
if (!SWIG_IsOK(res1)) {
|
11048
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > *","dump", 1, self ));
|
11049
|
+
}
|
11050
|
+
arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< double > * >(argp1);
|
11051
|
+
res3 = SWIG_ConvertPtr(argv[0], &argp3, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
|
11052
|
+
if (!SWIG_IsOK(res3)) {
|
11053
|
+
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "GPS_Time< double > const &","dump", 3, argv[0] ));
|
11054
|
+
}
|
11055
|
+
if (!argp3) {
|
11056
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","dump", 3, argv[0]));
|
11057
|
+
}
|
11058
|
+
arg3 = reinterpret_cast< GPS_Time< double > * >(argp3);
|
11059
|
+
{
|
11060
|
+
try {
|
11061
|
+
GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__dump(arg1,arg2,(GPS_Time< double > const &)*arg3);
|
11062
|
+
} catch (const native_exception &e) {
|
11063
|
+
e.regenerate();
|
11064
|
+
SWIG_fail;
|
11065
|
+
} catch (const std::exception& e) {
|
11066
|
+
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
11067
|
+
}
|
11068
|
+
}
|
11069
|
+
{
|
11070
|
+
for(int i(0); i < 10; ++i){
|
11071
|
+
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int ((arg2)[i]));
|
11072
|
+
}
|
11073
|
+
}
|
11074
|
+
return vresult;
|
11075
|
+
fail:
|
11076
|
+
return Qnil;
|
11077
|
+
}
|
11078
|
+
|
11079
|
+
|
10875
11080
|
SWIGINTERN VALUE
|
10876
11081
|
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
|
10877
11082
|
_wrap_Ionospheric_UTC_Parameters_allocate(VALUE self)
|
@@ -11087,6 +11292,143 @@ fail:
|
|
11087
11292
|
}
|
11088
11293
|
|
11089
11294
|
|
11295
|
+
/*
|
11296
|
+
Document-method: GPS_PVT::GPS::Ephemeris.valid?
|
11297
|
+
|
11298
|
+
call-seq:
|
11299
|
+
valid?(Time t) -> bool
|
11300
|
+
|
11301
|
+
An instance method.
|
11302
|
+
|
11303
|
+
*/
|
11304
|
+
SWIGINTERN VALUE
|
11305
|
+
_wrap_Ephemeris_validq___(int argc, VALUE *argv, VALUE self) {
|
11306
|
+
GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
|
11307
|
+
GPS_Time< double > *arg2 = 0 ;
|
11308
|
+
void *argp1 = 0 ;
|
11309
|
+
int res1 = 0 ;
|
11310
|
+
void *argp2 ;
|
11311
|
+
int res2 = 0 ;
|
11312
|
+
bool result;
|
11313
|
+
VALUE vresult = Qnil;
|
11314
|
+
|
11315
|
+
if ((argc < 1) || (argc > 1)) {
|
11316
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
11317
|
+
}
|
11318
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_EphemerisT_double_t, 0 | 0 );
|
11319
|
+
if (!SWIG_IsOK(res1)) {
|
11320
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","is_valid", 1, self ));
|
11321
|
+
}
|
11322
|
+
arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
|
11323
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
|
11324
|
+
if (!SWIG_IsOK(res2)) {
|
11325
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_Time< double > const &","is_valid", 2, argv[0] ));
|
11326
|
+
}
|
11327
|
+
if (!argp2) {
|
11328
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","is_valid", 2, argv[0]));
|
11329
|
+
}
|
11330
|
+
arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
|
11331
|
+
{
|
11332
|
+
try {
|
11333
|
+
result = (bool)((GPS_Ephemeris< double > const *)arg1)->is_valid((GPS_Time< double > const &)*arg2);
|
11334
|
+
} catch (const native_exception &e) {
|
11335
|
+
e.regenerate();
|
11336
|
+
SWIG_fail;
|
11337
|
+
} catch (const std::exception& e) {
|
11338
|
+
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
11339
|
+
}
|
11340
|
+
}
|
11341
|
+
vresult = SWIG_From_bool(static_cast< bool >(result));
|
11342
|
+
return vresult;
|
11343
|
+
fail:
|
11344
|
+
return Qnil;
|
11345
|
+
}
|
11346
|
+
|
11347
|
+
|
11348
|
+
/*
|
11349
|
+
Document-method: GPS_PVT::GPS::Ephemeris.t_clock
|
11350
|
+
|
11351
|
+
call-seq:
|
11352
|
+
t_clock -> Time
|
11353
|
+
|
11354
|
+
An instance method.
|
11355
|
+
|
11356
|
+
*/
|
11357
|
+
SWIGINTERN VALUE
|
11358
|
+
_wrap_Ephemeris_t_clock(int argc, VALUE *argv, VALUE self) {
|
11359
|
+
GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
|
11360
|
+
void *argp1 = 0 ;
|
11361
|
+
int res1 = 0 ;
|
11362
|
+
GPS_Time< double > result;
|
11363
|
+
VALUE vresult = Qnil;
|
11364
|
+
|
11365
|
+
if ((argc < 0) || (argc > 0)) {
|
11366
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
11367
|
+
}
|
11368
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_EphemerisT_double_t, 0 | 0 );
|
11369
|
+
if (!SWIG_IsOK(res1)) {
|
11370
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","t_clock", 1, self ));
|
11371
|
+
}
|
11372
|
+
arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
|
11373
|
+
{
|
11374
|
+
try {
|
11375
|
+
result = ((GPS_Ephemeris< double > const *)arg1)->t_clock();
|
11376
|
+
} catch (const native_exception &e) {
|
11377
|
+
e.regenerate();
|
11378
|
+
SWIG_fail;
|
11379
|
+
} catch (const std::exception& e) {
|
11380
|
+
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
11381
|
+
}
|
11382
|
+
}
|
11383
|
+
vresult = SWIG_NewPointerObj((new GPS_Time< double >(static_cast< const GPS_Time< double >& >(result))), SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_OWN | 0 );
|
11384
|
+
return vresult;
|
11385
|
+
fail:
|
11386
|
+
return Qnil;
|
11387
|
+
}
|
11388
|
+
|
11389
|
+
|
11390
|
+
/*
|
11391
|
+
Document-method: GPS_PVT::GPS::Ephemeris.t_ephemeris
|
11392
|
+
|
11393
|
+
call-seq:
|
11394
|
+
t_ephemeris -> Time
|
11395
|
+
|
11396
|
+
An instance method.
|
11397
|
+
|
11398
|
+
*/
|
11399
|
+
SWIGINTERN VALUE
|
11400
|
+
_wrap_Ephemeris_t_ephemeris(int argc, VALUE *argv, VALUE self) {
|
11401
|
+
GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
|
11402
|
+
void *argp1 = 0 ;
|
11403
|
+
int res1 = 0 ;
|
11404
|
+
GPS_Time< double > result;
|
11405
|
+
VALUE vresult = Qnil;
|
11406
|
+
|
11407
|
+
if ((argc < 0) || (argc > 0)) {
|
11408
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
11409
|
+
}
|
11410
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_EphemerisT_double_t, 0 | 0 );
|
11411
|
+
if (!SWIG_IsOK(res1)) {
|
11412
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","t_ephemeris", 1, self ));
|
11413
|
+
}
|
11414
|
+
arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
|
11415
|
+
{
|
11416
|
+
try {
|
11417
|
+
result = ((GPS_Ephemeris< double > const *)arg1)->t_ephemeris();
|
11418
|
+
} catch (const native_exception &e) {
|
11419
|
+
e.regenerate();
|
11420
|
+
SWIG_fail;
|
11421
|
+
} catch (const std::exception& e) {
|
11422
|
+
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
11423
|
+
}
|
11424
|
+
}
|
11425
|
+
vresult = SWIG_NewPointerObj((new GPS_Time< double >(static_cast< const GPS_Time< double >& >(result))), SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_OWN | 0 );
|
11426
|
+
return vresult;
|
11427
|
+
fail:
|
11428
|
+
return Qnil;
|
11429
|
+
}
|
11430
|
+
|
11431
|
+
|
11090
11432
|
/*
|
11091
11433
|
Document-method: GPS_PVT::GPS::Ephemeris.new
|
11092
11434
|
|
@@ -11395,7 +11737,7 @@ fail:
|
|
11395
11737
|
Document-method: GPS_PVT::GPS::Ephemeris.URA=
|
11396
11738
|
|
11397
11739
|
call-seq:
|
11398
|
-
URA=(
|
11740
|
+
URA=(double const & v) -> double
|
11399
11741
|
|
11400
11742
|
An instance method.
|
11401
11743
|
|
@@ -11403,13 +11745,13 @@ An instance method.
|
|
11403
11745
|
SWIGINTERN VALUE
|
11404
11746
|
_wrap_Ephemeris_URAe___(int argc, VALUE *argv, VALUE self) {
|
11405
11747
|
GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
|
11406
|
-
|
11748
|
+
double *arg2 = 0 ;
|
11407
11749
|
void *argp1 = 0 ;
|
11408
11750
|
int res1 = 0 ;
|
11409
|
-
|
11410
|
-
|
11751
|
+
double temp2 ;
|
11752
|
+
double val2 ;
|
11411
11753
|
int ecode2 = 0 ;
|
11412
|
-
|
11754
|
+
double result;
|
11413
11755
|
VALUE vresult = Qnil;
|
11414
11756
|
|
11415
11757
|
if ((argc < 1) || (argc > 1)) {
|
@@ -11420,15 +11762,15 @@ _wrap_Ephemeris_URAe___(int argc, VALUE *argv, VALUE self) {
|
|
11420
11762
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_URA", 1, self ));
|
11421
11763
|
}
|
11422
11764
|
arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
|
11423
|
-
ecode2 =
|
11765
|
+
ecode2 = SWIG_AsVal_double(argv[0], &val2);
|
11424
11766
|
if (!SWIG_IsOK(ecode2)) {
|
11425
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "
|
11767
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_URA", 2, argv[0] ));
|
11426
11768
|
}
|
11427
|
-
temp2 = static_cast<
|
11769
|
+
temp2 = static_cast< double >(val2);
|
11428
11770
|
arg2 = &temp2;
|
11429
11771
|
{
|
11430
11772
|
try {
|
11431
|
-
result = (
|
11773
|
+
result = (double)GPS_Ephemeris_Sl_double_Sg__set_URA(arg1,(double const &)*arg2);
|
11432
11774
|
} catch (const native_exception &e) {
|
11433
11775
|
e.regenerate();
|
11434
11776
|
SWIG_fail;
|
@@ -11436,7 +11778,7 @@ _wrap_Ephemeris_URAe___(int argc, VALUE *argv, VALUE self) {
|
|
11436
11778
|
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
11437
11779
|
}
|
11438
11780
|
}
|
11439
|
-
vresult =
|
11781
|
+
vresult = SWIG_From_double(static_cast< double >(result));
|
11440
11782
|
return vresult;
|
11441
11783
|
fail:
|
11442
11784
|
return Qnil;
|
@@ -11447,7 +11789,7 @@ fail:
|
|
11447
11789
|
Document-method: GPS_PVT::GPS::Ephemeris.URA
|
11448
11790
|
|
11449
11791
|
call-seq:
|
11450
|
-
URA ->
|
11792
|
+
URA -> double const &
|
11451
11793
|
|
11452
11794
|
An instance method.
|
11453
11795
|
|
@@ -11457,7 +11799,7 @@ _wrap_Ephemeris_URA(int argc, VALUE *argv, VALUE self) {
|
|
11457
11799
|
GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
|
11458
11800
|
void *argp1 = 0 ;
|
11459
11801
|
int res1 = 0 ;
|
11460
|
-
|
11802
|
+
double *result = 0 ;
|
11461
11803
|
VALUE vresult = Qnil;
|
11462
11804
|
|
11463
11805
|
if ((argc < 0) || (argc > 0)) {
|
@@ -11470,7 +11812,7 @@ _wrap_Ephemeris_URA(int argc, VALUE *argv, VALUE self) {
|
|
11470
11812
|
arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
|
11471
11813
|
{
|
11472
11814
|
try {
|
11473
|
-
result = (
|
11815
|
+
result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_URA((GPS_Ephemeris< double > const *)arg1);
|
11474
11816
|
} catch (const native_exception &e) {
|
11475
11817
|
e.regenerate();
|
11476
11818
|
SWIG_fail;
|
@@ -11478,7 +11820,7 @@ _wrap_Ephemeris_URA(int argc, VALUE *argv, VALUE self) {
|
|
11478
11820
|
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
11479
11821
|
}
|
11480
11822
|
}
|
11481
|
-
vresult =
|
11823
|
+
vresult = SWIG_From_double(static_cast< double >(*result));
|
11482
11824
|
return vresult;
|
11483
11825
|
fail:
|
11484
11826
|
return Qnil;
|
@@ -13910,28 +14252,344 @@ fail:
|
|
13910
14252
|
|
13911
14253
|
|
13912
14254
|
/*
|
13913
|
-
Document-method: GPS_PVT::GPS::Ephemeris.
|
14255
|
+
Document-method: GPS_PVT::GPS::Ephemeris.dump
|
13914
14256
|
|
13915
14257
|
call-seq:
|
13916
|
-
|
13917
|
-
constellation(Time t_tx) -> GPS_Ephemeris< double >::constellation_res_t
|
14258
|
+
dump(Time t)
|
13918
14259
|
|
13919
14260
|
An instance method.
|
13920
14261
|
|
13921
14262
|
*/
|
13922
14263
|
SWIGINTERN VALUE
|
13923
|
-
|
14264
|
+
_wrap_Ephemeris_dump(int argc, VALUE *argv, VALUE self) {
|
13924
14265
|
GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
|
13925
|
-
|
13926
|
-
|
14266
|
+
unsigned int *arg2 ;
|
14267
|
+
unsigned int *arg3 ;
|
14268
|
+
unsigned int *arg4 ;
|
14269
|
+
GPS_Time< double > *arg5 = 0 ;
|
13927
14270
|
void *argp1 = 0 ;
|
13928
14271
|
int res1 = 0 ;
|
13929
|
-
|
13930
|
-
|
13931
|
-
|
13932
|
-
|
13933
|
-
|
13934
|
-
|
14272
|
+
unsigned int temp2[10] = {
|
14273
|
+
0
|
14274
|
+
} ;
|
14275
|
+
unsigned int temp3[10] = {
|
14276
|
+
0
|
14277
|
+
} ;
|
14278
|
+
unsigned int temp4[10] = {
|
14279
|
+
0
|
14280
|
+
} ;
|
14281
|
+
void *argp5 ;
|
14282
|
+
int res5 = 0 ;
|
14283
|
+
VALUE vresult = Qnil;
|
14284
|
+
|
14285
|
+
arg2 = temp2;
|
14286
|
+
arg3 = temp3;
|
14287
|
+
arg4 = temp4;
|
14288
|
+
if ((argc < 1) || (argc > 1)) {
|
14289
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
14290
|
+
}
|
14291
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_EphemerisT_double_t, 0 | 0 );
|
14292
|
+
if (!SWIG_IsOK(res1)) {
|
14293
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","dump", 1, self ));
|
14294
|
+
}
|
14295
|
+
arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
|
14296
|
+
res5 = SWIG_ConvertPtr(argv[0], &argp5, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
|
14297
|
+
if (!SWIG_IsOK(res5)) {
|
14298
|
+
SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "GPS_Time< double > const &","dump", 5, argv[0] ));
|
14299
|
+
}
|
14300
|
+
if (!argp5) {
|
14301
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","dump", 5, argv[0]));
|
14302
|
+
}
|
14303
|
+
arg5 = reinterpret_cast< GPS_Time< double > * >(argp5);
|
14304
|
+
{
|
14305
|
+
try {
|
14306
|
+
GPS_Ephemeris_Sl_double_Sg__dump(arg1,arg2,arg3,arg4,(GPS_Time< double > const &)*arg5);
|
14307
|
+
} catch (const native_exception &e) {
|
14308
|
+
e.regenerate();
|
14309
|
+
SWIG_fail;
|
14310
|
+
} catch (const std::exception& e) {
|
14311
|
+
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
14312
|
+
}
|
14313
|
+
}
|
14314
|
+
vresult = rb_ary_new();
|
14315
|
+
{
|
14316
|
+
for(int i(0); i < 10; ++i){
|
14317
|
+
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int ((arg2)[i]));
|
14318
|
+
}
|
14319
|
+
}
|
14320
|
+
{
|
14321
|
+
for(int i(0); i < 10; ++i){
|
14322
|
+
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int ((arg3)[i]));
|
14323
|
+
}
|
14324
|
+
}
|
14325
|
+
{
|
14326
|
+
for(int i(0); i < 10; ++i){
|
14327
|
+
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int ((arg4)[i]));
|
14328
|
+
}
|
14329
|
+
}
|
14330
|
+
return vresult;
|
14331
|
+
fail:
|
14332
|
+
return Qnil;
|
14333
|
+
}
|
14334
|
+
|
14335
|
+
|
14336
|
+
/*
|
14337
|
+
Document-method: GPS_PVT::GPS::Ephemeris.parse_almanac
|
14338
|
+
|
14339
|
+
call-seq:
|
14340
|
+
parse_almanac(unsigned int const [10] buf) -> int
|
14341
|
+
|
14342
|
+
An instance method.
|
14343
|
+
|
14344
|
+
*/
|
14345
|
+
SWIGINTERN VALUE
|
14346
|
+
_wrap_Ephemeris_parse_almanac(int argc, VALUE *argv, VALUE self) {
|
14347
|
+
GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
|
14348
|
+
unsigned int *arg2 ;
|
14349
|
+
void *argp1 = 0 ;
|
14350
|
+
int res1 = 0 ;
|
14351
|
+
unsigned int temp2[10] ;
|
14352
|
+
int result;
|
14353
|
+
VALUE vresult = Qnil;
|
14354
|
+
|
14355
|
+
if ((argc < 1) || (argc > 1)) {
|
14356
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
14357
|
+
}
|
14358
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_EphemerisT_double_t, 0 | 0 );
|
14359
|
+
if (!SWIG_IsOK(res1)) {
|
14360
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","parse_almanac", 1, self ));
|
14361
|
+
}
|
14362
|
+
arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
|
14363
|
+
{
|
14364
|
+
if(!(RB_TYPE_P(argv[0], T_ARRAY) && (RARRAY_LEN(argv[0]) == 10))){
|
14365
|
+
SWIG_exception(SWIG_TypeError, "array[10] is expected");
|
14366
|
+
}
|
14367
|
+
for(int i(0); i < 10; ++i){
|
14368
|
+
if(!SWIG_IsOK(SWIG_AsVal_unsigned_SS_int (RARRAY_AREF(argv[0], i), &temp2[i]))){
|
14369
|
+
SWIG_exception(SWIG_TypeError, "unsigned int is expected");
|
14370
|
+
}
|
14371
|
+
}
|
14372
|
+
arg2 = temp2;
|
14373
|
+
}
|
14374
|
+
{
|
14375
|
+
try {
|
14376
|
+
result = (int)GPS_Ephemeris_Sl_double_Sg__parse_almanac(arg1,(unsigned int const (*))arg2);
|
14377
|
+
} catch (const native_exception &e) {
|
14378
|
+
e.regenerate();
|
14379
|
+
SWIG_fail;
|
14380
|
+
} catch (const std::exception& e) {
|
14381
|
+
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
14382
|
+
}
|
14383
|
+
}
|
14384
|
+
vresult = SWIG_From_int(static_cast< int >(result));
|
14385
|
+
return vresult;
|
14386
|
+
fail:
|
14387
|
+
return Qnil;
|
14388
|
+
}
|
14389
|
+
|
14390
|
+
|
14391
|
+
/*
|
14392
|
+
Document-method: GPS_PVT::GPS::Ephemeris.dump_almanac
|
14393
|
+
|
14394
|
+
call-seq:
|
14395
|
+
dump_almanac(Time t, unsigned int const & qzss_subframe=0)
|
14396
|
+
dump_almanac(Time t)
|
14397
|
+
|
14398
|
+
An instance method.
|
14399
|
+
|
14400
|
+
*/
|
14401
|
+
SWIGINTERN VALUE
|
14402
|
+
_wrap_Ephemeris_dump_almanac__SWIG_0(int argc, VALUE *argv, VALUE self) {
|
14403
|
+
GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
|
14404
|
+
unsigned int *arg2 ;
|
14405
|
+
GPS_Time< double > *arg3 = 0 ;
|
14406
|
+
unsigned int *arg4 = 0 ;
|
14407
|
+
void *argp1 = 0 ;
|
14408
|
+
int res1 = 0 ;
|
14409
|
+
unsigned int temp2[10] = {
|
14410
|
+
0
|
14411
|
+
} ;
|
14412
|
+
void *argp3 ;
|
14413
|
+
int res3 = 0 ;
|
14414
|
+
unsigned int temp4 ;
|
14415
|
+
unsigned int val4 ;
|
14416
|
+
int ecode4 = 0 ;
|
14417
|
+
VALUE vresult = Qnil;
|
14418
|
+
|
14419
|
+
arg2 = temp2;
|
14420
|
+
if ((argc < 2) || (argc > 2)) {
|
14421
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
14422
|
+
}
|
14423
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_EphemerisT_double_t, 0 | 0 );
|
14424
|
+
if (!SWIG_IsOK(res1)) {
|
14425
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","dump_almanac", 1, self ));
|
14426
|
+
}
|
14427
|
+
arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
|
14428
|
+
res3 = SWIG_ConvertPtr(argv[0], &argp3, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
|
14429
|
+
if (!SWIG_IsOK(res3)) {
|
14430
|
+
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "GPS_Time< double > const &","dump_almanac", 3, argv[0] ));
|
14431
|
+
}
|
14432
|
+
if (!argp3) {
|
14433
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","dump_almanac", 3, argv[0]));
|
14434
|
+
}
|
14435
|
+
arg3 = reinterpret_cast< GPS_Time< double > * >(argp3);
|
14436
|
+
ecode4 = SWIG_AsVal_unsigned_SS_int(argv[1], &val4);
|
14437
|
+
if (!SWIG_IsOK(ecode4)) {
|
14438
|
+
SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","dump_almanac", 4, argv[1] ));
|
14439
|
+
}
|
14440
|
+
temp4 = static_cast< unsigned int >(val4);
|
14441
|
+
arg4 = &temp4;
|
14442
|
+
{
|
14443
|
+
try {
|
14444
|
+
GPS_Ephemeris_Sl_double_Sg__dump_almanac__SWIG_0(arg1,arg2,(GPS_Time< double > const &)*arg3,(unsigned int const &)*arg4);
|
14445
|
+
} catch (const native_exception &e) {
|
14446
|
+
e.regenerate();
|
14447
|
+
SWIG_fail;
|
14448
|
+
} catch (const std::exception& e) {
|
14449
|
+
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
14450
|
+
}
|
14451
|
+
}
|
14452
|
+
{
|
14453
|
+
for(int i(0); i < 10; ++i){
|
14454
|
+
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int ((arg2)[i]));
|
14455
|
+
}
|
14456
|
+
}
|
14457
|
+
return vresult;
|
14458
|
+
fail:
|
14459
|
+
return Qnil;
|
14460
|
+
}
|
14461
|
+
|
14462
|
+
|
14463
|
+
SWIGINTERN VALUE
|
14464
|
+
_wrap_Ephemeris_dump_almanac__SWIG_1(int argc, VALUE *argv, VALUE self) {
|
14465
|
+
GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
|
14466
|
+
unsigned int *arg2 ;
|
14467
|
+
GPS_Time< double > *arg3 = 0 ;
|
14468
|
+
void *argp1 = 0 ;
|
14469
|
+
int res1 = 0 ;
|
14470
|
+
unsigned int temp2[10] = {
|
14471
|
+
0
|
14472
|
+
} ;
|
14473
|
+
void *argp3 ;
|
14474
|
+
int res3 = 0 ;
|
14475
|
+
VALUE vresult = Qnil;
|
14476
|
+
|
14477
|
+
arg2 = temp2;
|
14478
|
+
if ((argc < 1) || (argc > 1)) {
|
14479
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
14480
|
+
}
|
14481
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_EphemerisT_double_t, 0 | 0 );
|
14482
|
+
if (!SWIG_IsOK(res1)) {
|
14483
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","dump_almanac", 1, self ));
|
14484
|
+
}
|
14485
|
+
arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
|
14486
|
+
res3 = SWIG_ConvertPtr(argv[0], &argp3, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
|
14487
|
+
if (!SWIG_IsOK(res3)) {
|
14488
|
+
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "GPS_Time< double > const &","dump_almanac", 3, argv[0] ));
|
14489
|
+
}
|
14490
|
+
if (!argp3) {
|
14491
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","dump_almanac", 3, argv[0]));
|
14492
|
+
}
|
14493
|
+
arg3 = reinterpret_cast< GPS_Time< double > * >(argp3);
|
14494
|
+
{
|
14495
|
+
try {
|
14496
|
+
GPS_Ephemeris_Sl_double_Sg__dump_almanac__SWIG_0(arg1,arg2,(GPS_Time< double > const &)*arg3);
|
14497
|
+
} catch (const native_exception &e) {
|
14498
|
+
e.regenerate();
|
14499
|
+
SWIG_fail;
|
14500
|
+
} catch (const std::exception& e) {
|
14501
|
+
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
14502
|
+
}
|
14503
|
+
}
|
14504
|
+
{
|
14505
|
+
for(int i(0); i < 10; ++i){
|
14506
|
+
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int ((arg2)[i]));
|
14507
|
+
}
|
14508
|
+
}
|
14509
|
+
return vresult;
|
14510
|
+
fail:
|
14511
|
+
return Qnil;
|
14512
|
+
}
|
14513
|
+
|
14514
|
+
|
14515
|
+
SWIGINTERN VALUE _wrap_Ephemeris_dump_almanac(int nargs, VALUE *args, VALUE self) {
|
14516
|
+
int argc;
|
14517
|
+
VALUE argv[4];
|
14518
|
+
int ii;
|
14519
|
+
|
14520
|
+
argc = nargs + 1;
|
14521
|
+
argv[0] = self;
|
14522
|
+
if (argc > 4) SWIG_fail;
|
14523
|
+
for (ii = 1; (ii < argc); ++ii) {
|
14524
|
+
argv[ii] = args[ii-1];
|
14525
|
+
}
|
14526
|
+
if (argc == 2) {
|
14527
|
+
int _v;
|
14528
|
+
void *vptr = 0;
|
14529
|
+
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_EphemerisT_double_t, 0);
|
14530
|
+
_v = SWIG_CheckState(res);
|
14531
|
+
if (_v) {
|
14532
|
+
void *vptr = 0;
|
14533
|
+
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_NO_NULL);
|
14534
|
+
_v = SWIG_CheckState(res);
|
14535
|
+
if (_v) {
|
14536
|
+
return _wrap_Ephemeris_dump_almanac__SWIG_1(nargs, args, self);
|
14537
|
+
}
|
14538
|
+
}
|
14539
|
+
}
|
14540
|
+
if (argc == 3) {
|
14541
|
+
int _v;
|
14542
|
+
void *vptr = 0;
|
14543
|
+
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_EphemerisT_double_t, 0);
|
14544
|
+
_v = SWIG_CheckState(res);
|
14545
|
+
if (_v) {
|
14546
|
+
void *vptr = 0;
|
14547
|
+
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_NO_NULL);
|
14548
|
+
_v = SWIG_CheckState(res);
|
14549
|
+
if (_v) {
|
14550
|
+
{
|
14551
|
+
int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
|
14552
|
+
_v = SWIG_CheckState(res);
|
14553
|
+
}
|
14554
|
+
if (_v) {
|
14555
|
+
return _wrap_Ephemeris_dump_almanac__SWIG_0(nargs, args, self);
|
14556
|
+
}
|
14557
|
+
}
|
14558
|
+
}
|
14559
|
+
}
|
14560
|
+
|
14561
|
+
fail:
|
14562
|
+
Ruby_Format_OverloadedError( argc, 4, "dump_almanac",
|
14563
|
+
" void dump_almanac(unsigned int buf_brdc[10], GPS_Time< double > const &t, unsigned int const &qzss_subframe)\n"
|
14564
|
+
" void dump_almanac(unsigned int buf_brdc[10], GPS_Time< double > const &t)\n");
|
14565
|
+
|
14566
|
+
return Qnil;
|
14567
|
+
}
|
14568
|
+
|
14569
|
+
|
14570
|
+
/*
|
14571
|
+
Document-method: GPS_PVT::GPS::Ephemeris.constellation
|
14572
|
+
|
14573
|
+
call-seq:
|
14574
|
+
constellation(Time t_tx, double const & dt_transit=0) -> GPS_Ephemeris< double >::constellation_res_t
|
14575
|
+
constellation(Time t_tx) -> GPS_Ephemeris< double >::constellation_res_t
|
14576
|
+
|
14577
|
+
An instance method.
|
14578
|
+
|
14579
|
+
*/
|
14580
|
+
SWIGINTERN VALUE
|
14581
|
+
_wrap_Ephemeris_constellation__SWIG_0(int argc, VALUE *argv, VALUE self) {
|
14582
|
+
GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
|
14583
|
+
GPS_Time< double > *arg2 = 0 ;
|
14584
|
+
double *arg3 = 0 ;
|
14585
|
+
void *argp1 = 0 ;
|
14586
|
+
int res1 = 0 ;
|
14587
|
+
void *argp2 ;
|
14588
|
+
int res2 = 0 ;
|
14589
|
+
double temp3 ;
|
14590
|
+
double val3 ;
|
14591
|
+
int ecode3 = 0 ;
|
14592
|
+
GPS_Ephemeris< double >::constellation_res_t result;
|
13935
14593
|
VALUE vresult = Qnil;
|
13936
14594
|
|
13937
14595
|
if ((argc < 2) || (argc > 2)) {
|
@@ -17450,21 +18108,116 @@ SWIGINTERN VALUE _wrap_new_Ephemeris_SBAS(int nargs, VALUE *args, VALUE self) {
|
|
17450
18108
|
if (argc == 0) {
|
17451
18109
|
return _wrap_new_Ephemeris_SBAS__SWIG_0(nargs, args, self);
|
17452
18110
|
}
|
17453
|
-
if (argc == 1) {
|
17454
|
-
int _v;
|
17455
|
-
void *vptr = 0;
|
17456
|
-
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBAS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris, SWIG_POINTER_NO_NULL);
|
17457
|
-
_v = SWIG_CheckState(res);
|
17458
|
-
if (_v) {
|
17459
|
-
return _wrap_new_Ephemeris_SBAS__SWIG_1(nargs, args, self);
|
18111
|
+
if (argc == 1) {
|
18112
|
+
int _v;
|
18113
|
+
void *vptr = 0;
|
18114
|
+
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBAS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris, SWIG_POINTER_NO_NULL);
|
18115
|
+
_v = SWIG_CheckState(res);
|
18116
|
+
if (_v) {
|
18117
|
+
return _wrap_new_Ephemeris_SBAS__SWIG_1(nargs, args, self);
|
18118
|
+
}
|
18119
|
+
}
|
18120
|
+
|
18121
|
+
fail:
|
18122
|
+
Ruby_Format_OverloadedError( argc, 1, "Ephemeris_SBAS.new",
|
18123
|
+
" Ephemeris_SBAS.new()\n"
|
18124
|
+
" Ephemeris_SBAS.new(SBAS_SpaceNode< double >::SatelliteProperties::Ephemeris const &eph)\n");
|
18125
|
+
|
18126
|
+
return Qnil;
|
18127
|
+
}
|
18128
|
+
|
18129
|
+
|
18130
|
+
/*
|
18131
|
+
Document-method: GPS_PVT::GPS::Ephemeris_SBAS.valid?
|
18132
|
+
|
18133
|
+
call-seq:
|
18134
|
+
valid?(Time t) -> bool
|
18135
|
+
|
18136
|
+
An instance method.
|
18137
|
+
|
18138
|
+
*/
|
18139
|
+
SWIGINTERN VALUE
|
18140
|
+
_wrap_Ephemeris_SBAS_validq___(int argc, VALUE *argv, VALUE self) {
|
18141
|
+
SBAS_Ephemeris< double > *arg1 = (SBAS_Ephemeris< double > *) 0 ;
|
18142
|
+
GPS_Time< double > *arg2 = 0 ;
|
18143
|
+
void *argp1 = 0 ;
|
18144
|
+
int res1 = 0 ;
|
18145
|
+
void *argp2 ;
|
18146
|
+
int res2 = 0 ;
|
18147
|
+
bool result;
|
18148
|
+
VALUE vresult = Qnil;
|
18149
|
+
|
18150
|
+
if ((argc < 1) || (argc > 1)) {
|
18151
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
18152
|
+
}
|
18153
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SBAS_EphemerisT_double_t, 0 | 0 );
|
18154
|
+
if (!SWIG_IsOK(res1)) {
|
18155
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_Ephemeris< double > const *","is_valid", 1, self ));
|
18156
|
+
}
|
18157
|
+
arg1 = reinterpret_cast< SBAS_Ephemeris< double > * >(argp1);
|
18158
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
|
18159
|
+
if (!SWIG_IsOK(res2)) {
|
18160
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_Time< double > const &","is_valid", 2, argv[0] ));
|
18161
|
+
}
|
18162
|
+
if (!argp2) {
|
18163
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","is_valid", 2, argv[0]));
|
18164
|
+
}
|
18165
|
+
arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
|
18166
|
+
{
|
18167
|
+
try {
|
18168
|
+
result = (bool)((SBAS_Ephemeris< double > const *)arg1)->is_valid((GPS_Time< double > const &)*arg2);
|
18169
|
+
} catch (const native_exception &e) {
|
18170
|
+
e.regenerate();
|
18171
|
+
SWIG_fail;
|
18172
|
+
} catch (const std::exception& e) {
|
18173
|
+
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
18174
|
+
}
|
18175
|
+
}
|
18176
|
+
vresult = SWIG_From_bool(static_cast< bool >(result));
|
18177
|
+
return vresult;
|
18178
|
+
fail:
|
18179
|
+
return Qnil;
|
18180
|
+
}
|
18181
|
+
|
18182
|
+
|
18183
|
+
/*
|
18184
|
+
Document-method: GPS_PVT::GPS::Ephemeris_SBAS.t_applicable
|
18185
|
+
|
18186
|
+
call-seq:
|
18187
|
+
t_applicable -> Time
|
18188
|
+
|
18189
|
+
An instance method.
|
18190
|
+
|
18191
|
+
*/
|
18192
|
+
SWIGINTERN VALUE
|
18193
|
+
_wrap_Ephemeris_SBAS_t_applicable(int argc, VALUE *argv, VALUE self) {
|
18194
|
+
SBAS_Ephemeris< double > *arg1 = (SBAS_Ephemeris< double > *) 0 ;
|
18195
|
+
void *argp1 = 0 ;
|
18196
|
+
int res1 = 0 ;
|
18197
|
+
GPS_Time< double > result;
|
18198
|
+
VALUE vresult = Qnil;
|
18199
|
+
|
18200
|
+
if ((argc < 0) || (argc > 0)) {
|
18201
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
18202
|
+
}
|
18203
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SBAS_EphemerisT_double_t, 0 | 0 );
|
18204
|
+
if (!SWIG_IsOK(res1)) {
|
18205
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_Ephemeris< double > const *","t_applicable", 1, self ));
|
18206
|
+
}
|
18207
|
+
arg1 = reinterpret_cast< SBAS_Ephemeris< double > * >(argp1);
|
18208
|
+
{
|
18209
|
+
try {
|
18210
|
+
result = ((SBAS_Ephemeris< double > const *)arg1)->t_applicable();
|
18211
|
+
} catch (const native_exception &e) {
|
18212
|
+
e.regenerate();
|
18213
|
+
SWIG_fail;
|
18214
|
+
} catch (const std::exception& e) {
|
18215
|
+
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
17460
18216
|
}
|
17461
18217
|
}
|
17462
|
-
|
18218
|
+
vresult = SWIG_NewPointerObj((new GPS_Time< double >(static_cast< const GPS_Time< double >& >(result))), SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_OWN | 0 );
|
18219
|
+
return vresult;
|
17463
18220
|
fail:
|
17464
|
-
Ruby_Format_OverloadedError( argc, 1, "Ephemeris_SBAS.new",
|
17465
|
-
" Ephemeris_SBAS.new()\n"
|
17466
|
-
" Ephemeris_SBAS.new(SBAS_SpaceNode< double >::SatelliteProperties::Ephemeris const &eph)\n");
|
17467
|
-
|
17468
18221
|
return Qnil;
|
17469
18222
|
}
|
17470
18223
|
|
@@ -18879,6 +19632,153 @@ fail:
|
|
18879
19632
|
}
|
18880
19633
|
|
18881
19634
|
|
19635
|
+
/*
|
19636
|
+
Document-method: GPS_PVT::GPS::Ephemeris_SBAS.dump
|
19637
|
+
|
19638
|
+
call-seq:
|
19639
|
+
dump(unsigned int const & preamble_idx=0)
|
19640
|
+
dump
|
19641
|
+
|
19642
|
+
An instance method.
|
19643
|
+
|
19644
|
+
*/
|
19645
|
+
SWIGINTERN VALUE
|
19646
|
+
_wrap_Ephemeris_SBAS_dump__SWIG_0(int argc, VALUE *argv, VALUE self) {
|
19647
|
+
SBAS_Ephemeris< double > *arg1 = (SBAS_Ephemeris< double > *) 0 ;
|
19648
|
+
unsigned int *arg2 ;
|
19649
|
+
unsigned int *arg3 = 0 ;
|
19650
|
+
void *argp1 = 0 ;
|
19651
|
+
int res1 = 0 ;
|
19652
|
+
unsigned int temp2[8] = {
|
19653
|
+
0
|
19654
|
+
} ;
|
19655
|
+
unsigned int temp3 ;
|
19656
|
+
unsigned int val3 ;
|
19657
|
+
int ecode3 = 0 ;
|
19658
|
+
VALUE vresult = Qnil;
|
19659
|
+
|
19660
|
+
arg2 = temp2;
|
19661
|
+
if ((argc < 1) || (argc > 1)) {
|
19662
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
19663
|
+
}
|
19664
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SBAS_EphemerisT_double_t, 0 | 0 );
|
19665
|
+
if (!SWIG_IsOK(res1)) {
|
19666
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_Ephemeris< double > *","dump", 1, self ));
|
19667
|
+
}
|
19668
|
+
arg1 = reinterpret_cast< SBAS_Ephemeris< double > * >(argp1);
|
19669
|
+
ecode3 = SWIG_AsVal_unsigned_SS_int(argv[0], &val3);
|
19670
|
+
if (!SWIG_IsOK(ecode3)) {
|
19671
|
+
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","dump", 3, argv[0] ));
|
19672
|
+
}
|
19673
|
+
temp3 = static_cast< unsigned int >(val3);
|
19674
|
+
arg3 = &temp3;
|
19675
|
+
{
|
19676
|
+
try {
|
19677
|
+
SBAS_Ephemeris_Sl_double_Sg__dump__SWIG_0(arg1,arg2,(unsigned int const &)*arg3);
|
19678
|
+
} catch (const native_exception &e) {
|
19679
|
+
e.regenerate();
|
19680
|
+
SWIG_fail;
|
19681
|
+
} catch (const std::exception& e) {
|
19682
|
+
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
19683
|
+
}
|
19684
|
+
}
|
19685
|
+
{
|
19686
|
+
for(int i(0); i < 8; ++i){
|
19687
|
+
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int ((arg2)[i]));
|
19688
|
+
}
|
19689
|
+
}
|
19690
|
+
return vresult;
|
19691
|
+
fail:
|
19692
|
+
return Qnil;
|
19693
|
+
}
|
19694
|
+
|
19695
|
+
|
19696
|
+
SWIGINTERN VALUE
|
19697
|
+
_wrap_Ephemeris_SBAS_dump__SWIG_1(int argc, VALUE *argv, VALUE self) {
|
19698
|
+
SBAS_Ephemeris< double > *arg1 = (SBAS_Ephemeris< double > *) 0 ;
|
19699
|
+
unsigned int *arg2 ;
|
19700
|
+
void *argp1 = 0 ;
|
19701
|
+
int res1 = 0 ;
|
19702
|
+
unsigned int temp2[8] = {
|
19703
|
+
0
|
19704
|
+
} ;
|
19705
|
+
VALUE vresult = Qnil;
|
19706
|
+
|
19707
|
+
arg2 = temp2;
|
19708
|
+
if ((argc < 0) || (argc > 0)) {
|
19709
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
19710
|
+
}
|
19711
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SBAS_EphemerisT_double_t, 0 | 0 );
|
19712
|
+
if (!SWIG_IsOK(res1)) {
|
19713
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_Ephemeris< double > *","dump", 1, self ));
|
19714
|
+
}
|
19715
|
+
arg1 = reinterpret_cast< SBAS_Ephemeris< double > * >(argp1);
|
19716
|
+
{
|
19717
|
+
try {
|
19718
|
+
SBAS_Ephemeris_Sl_double_Sg__dump__SWIG_0(arg1,arg2);
|
19719
|
+
} catch (const native_exception &e) {
|
19720
|
+
e.regenerate();
|
19721
|
+
SWIG_fail;
|
19722
|
+
} catch (const std::exception& e) {
|
19723
|
+
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
19724
|
+
}
|
19725
|
+
}
|
19726
|
+
{
|
19727
|
+
for(int i(0); i < 8; ++i){
|
19728
|
+
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int ((arg2)[i]));
|
19729
|
+
}
|
19730
|
+
}
|
19731
|
+
return vresult;
|
19732
|
+
fail:
|
19733
|
+
return Qnil;
|
19734
|
+
}
|
19735
|
+
|
19736
|
+
|
19737
|
+
SWIGINTERN VALUE _wrap_Ephemeris_SBAS_dump(int nargs, VALUE *args, VALUE self) {
|
19738
|
+
int argc;
|
19739
|
+
VALUE argv[3];
|
19740
|
+
int ii;
|
19741
|
+
|
19742
|
+
argc = nargs + 1;
|
19743
|
+
argv[0] = self;
|
19744
|
+
if (argc > 3) SWIG_fail;
|
19745
|
+
for (ii = 1; (ii < argc); ++ii) {
|
19746
|
+
argv[ii] = args[ii-1];
|
19747
|
+
}
|
19748
|
+
if (argc == 1) {
|
19749
|
+
int _v;
|
19750
|
+
void *vptr = 0;
|
19751
|
+
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBAS_EphemerisT_double_t, 0);
|
19752
|
+
_v = SWIG_CheckState(res);
|
19753
|
+
if (_v) {
|
19754
|
+
return _wrap_Ephemeris_SBAS_dump__SWIG_1(nargs, args, self);
|
19755
|
+
}
|
19756
|
+
}
|
19757
|
+
if (argc == 2) {
|
19758
|
+
int _v;
|
19759
|
+
void *vptr = 0;
|
19760
|
+
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBAS_EphemerisT_double_t, 0);
|
19761
|
+
_v = SWIG_CheckState(res);
|
19762
|
+
if (_v) {
|
19763
|
+
{
|
19764
|
+
int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
|
19765
|
+
_v = SWIG_CheckState(res);
|
19766
|
+
}
|
19767
|
+
if (_v) {
|
19768
|
+
return _wrap_Ephemeris_SBAS_dump__SWIG_0(nargs, args, self);
|
19769
|
+
}
|
19770
|
+
}
|
19771
|
+
}
|
19772
|
+
|
19773
|
+
fail:
|
19774
|
+
Ruby_Format_OverloadedError( argc, 3, "dump",
|
19775
|
+
" void dump(unsigned int buf_brdc[8], unsigned int const &preamble_idx)\n"
|
19776
|
+
" void dump(unsigned int buf_brdc[8])\n");
|
19777
|
+
|
19778
|
+
return Qnil;
|
19779
|
+
}
|
19780
|
+
|
19781
|
+
|
18882
19782
|
/*
|
18883
19783
|
Document-method: GPS_PVT::GPS::Ephemeris_SBAS.constellation
|
18884
19784
|
|
@@ -21479,6 +22379,59 @@ fail:
|
|
21479
22379
|
}
|
21480
22380
|
|
21481
22381
|
|
22382
|
+
/*
|
22383
|
+
Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.valid?
|
22384
|
+
|
22385
|
+
call-seq:
|
22386
|
+
valid?(Time t) -> bool
|
22387
|
+
|
22388
|
+
An instance method.
|
22389
|
+
|
22390
|
+
*/
|
22391
|
+
SWIGINTERN VALUE
|
22392
|
+
_wrap_Ephemeris_GLONASS_validq___(int argc, VALUE *argv, VALUE self) {
|
22393
|
+
GLONASS_Ephemeris< double > *arg1 = (GLONASS_Ephemeris< double > *) 0 ;
|
22394
|
+
GPS_Time< double > *arg2 = 0 ;
|
22395
|
+
void *argp1 = 0 ;
|
22396
|
+
int res1 = 0 ;
|
22397
|
+
void *argp2 ;
|
22398
|
+
int res2 = 0 ;
|
22399
|
+
bool result;
|
22400
|
+
VALUE vresult = Qnil;
|
22401
|
+
|
22402
|
+
if ((argc < 1) || (argc > 1)) {
|
22403
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
22404
|
+
}
|
22405
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLONASS_EphemerisT_double_t, 0 | 0 );
|
22406
|
+
if (!SWIG_IsOK(res1)) {
|
22407
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GLONASS_Ephemeris< double > const *","is_valid", 1, self ));
|
22408
|
+
}
|
22409
|
+
arg1 = reinterpret_cast< GLONASS_Ephemeris< double > * >(argp1);
|
22410
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
|
22411
|
+
if (!SWIG_IsOK(res2)) {
|
22412
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_Time< double > const &","is_valid", 2, argv[0] ));
|
22413
|
+
}
|
22414
|
+
if (!argp2) {
|
22415
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","is_valid", 2, argv[0]));
|
22416
|
+
}
|
22417
|
+
arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
|
22418
|
+
{
|
22419
|
+
try {
|
22420
|
+
result = (bool)((GLONASS_Ephemeris< double > const *)arg1)->is_valid((GPS_Time< double > const &)*arg2);
|
22421
|
+
} catch (const native_exception &e) {
|
22422
|
+
e.regenerate();
|
22423
|
+
SWIG_fail;
|
22424
|
+
} catch (const std::exception& e) {
|
22425
|
+
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
22426
|
+
}
|
22427
|
+
}
|
22428
|
+
vresult = SWIG_From_bool(static_cast< bool >(result));
|
22429
|
+
return vresult;
|
22430
|
+
fail:
|
22431
|
+
return Qnil;
|
22432
|
+
}
|
22433
|
+
|
22434
|
+
|
21482
22435
|
/*
|
21483
22436
|
Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.new
|
21484
22437
|
|
@@ -24520,6 +25473,108 @@ fail:
|
|
24520
25473
|
}
|
24521
25474
|
|
24522
25475
|
|
25476
|
+
/*
|
25477
|
+
Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.dump
|
25478
|
+
|
25479
|
+
call-seq:
|
25480
|
+
dump(Time t)
|
25481
|
+
|
25482
|
+
An instance method.
|
25483
|
+
|
25484
|
+
*/
|
25485
|
+
SWIGINTERN VALUE
|
25486
|
+
_wrap_Ephemeris_GLONASS_dump(int argc, VALUE *argv, VALUE self) {
|
25487
|
+
GLONASS_Ephemeris< double > *arg1 = (GLONASS_Ephemeris< double > *) 0 ;
|
25488
|
+
unsigned int *arg2 ;
|
25489
|
+
unsigned int *arg3 ;
|
25490
|
+
unsigned int *arg4 ;
|
25491
|
+
unsigned int *arg5 ;
|
25492
|
+
unsigned int *arg6 ;
|
25493
|
+
GPS_Time< double > *arg7 = 0 ;
|
25494
|
+
void *argp1 = 0 ;
|
25495
|
+
int res1 = 0 ;
|
25496
|
+
unsigned int temp2[3] = {
|
25497
|
+
0
|
25498
|
+
} ;
|
25499
|
+
unsigned int temp3[3] = {
|
25500
|
+
0
|
25501
|
+
} ;
|
25502
|
+
unsigned int temp4[3] = {
|
25503
|
+
0
|
25504
|
+
} ;
|
25505
|
+
unsigned int temp5[3] = {
|
25506
|
+
0
|
25507
|
+
} ;
|
25508
|
+
unsigned int temp6[3] = {
|
25509
|
+
0
|
25510
|
+
} ;
|
25511
|
+
void *argp7 ;
|
25512
|
+
int res7 = 0 ;
|
25513
|
+
VALUE vresult = Qnil;
|
25514
|
+
|
25515
|
+
arg2 = temp2;
|
25516
|
+
arg3 = temp3;
|
25517
|
+
arg4 = temp4;
|
25518
|
+
arg5 = temp5;
|
25519
|
+
arg6 = temp6;
|
25520
|
+
if ((argc < 1) || (argc > 1)) {
|
25521
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
25522
|
+
}
|
25523
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLONASS_EphemerisT_double_t, 0 | 0 );
|
25524
|
+
if (!SWIG_IsOK(res1)) {
|
25525
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GLONASS_Ephemeris< double > *","dump", 1, self ));
|
25526
|
+
}
|
25527
|
+
arg1 = reinterpret_cast< GLONASS_Ephemeris< double > * >(argp1);
|
25528
|
+
res7 = SWIG_ConvertPtr(argv[0], &argp7, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
|
25529
|
+
if (!SWIG_IsOK(res7)) {
|
25530
|
+
SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "GPS_Time< double > const &","dump", 7, argv[0] ));
|
25531
|
+
}
|
25532
|
+
if (!argp7) {
|
25533
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","dump", 7, argv[0]));
|
25534
|
+
}
|
25535
|
+
arg7 = reinterpret_cast< GPS_Time< double > * >(argp7);
|
25536
|
+
{
|
25537
|
+
try {
|
25538
|
+
GLONASS_Ephemeris_Sl_double_Sg__dump(arg1,arg2,arg3,arg4,arg5,arg6,(GPS_Time< double > const &)*arg7);
|
25539
|
+
} catch (const native_exception &e) {
|
25540
|
+
e.regenerate();
|
25541
|
+
SWIG_fail;
|
25542
|
+
} catch (const std::exception& e) {
|
25543
|
+
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
25544
|
+
}
|
25545
|
+
}
|
25546
|
+
vresult = rb_ary_new();
|
25547
|
+
{
|
25548
|
+
for(int i(0); i < 3; ++i){
|
25549
|
+
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int ((arg2)[i]));
|
25550
|
+
}
|
25551
|
+
}
|
25552
|
+
{
|
25553
|
+
for(int i(0); i < 3; ++i){
|
25554
|
+
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int ((arg3)[i]));
|
25555
|
+
}
|
25556
|
+
}
|
25557
|
+
{
|
25558
|
+
for(int i(0); i < 3; ++i){
|
25559
|
+
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int ((arg4)[i]));
|
25560
|
+
}
|
25561
|
+
}
|
25562
|
+
{
|
25563
|
+
for(int i(0); i < 3; ++i){
|
25564
|
+
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int ((arg5)[i]));
|
25565
|
+
}
|
25566
|
+
}
|
25567
|
+
{
|
25568
|
+
for(int i(0); i < 3; ++i){
|
25569
|
+
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int ((arg6)[i]));
|
25570
|
+
}
|
25571
|
+
}
|
25572
|
+
return vresult;
|
25573
|
+
fail:
|
25574
|
+
return Qnil;
|
25575
|
+
}
|
25576
|
+
|
25577
|
+
|
24523
25578
|
/*
|
24524
25579
|
Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.constellation
|
24525
25580
|
|
@@ -26272,6 +27327,7 @@ static swig_type_info _swigt__p_u16_t = {"_p_u16_t", "u16_t *", 0, 0, (void*)0,
|
|
26272
27327
|
static swig_type_info _swigt__p_u32_t = {"_p_u32_t", "u32_t *", 0, 0, (void*)0, 0};
|
26273
27328
|
static swig_type_info _swigt__p_u8_t = {"_p_u8_t", "u8_t *", 0, 0, (void*)0, 0};
|
26274
27329
|
static swig_type_info _swigt__p_uint_t = {"_p_uint_t", "uint_t *", 0, 0, (void*)0, 0};
|
27330
|
+
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *", 0, 0, (void*)0, 0};
|
26275
27331
|
static swig_type_info _swigt__p_xyz_t = {"_p_xyz_t", "xyz_t *", 0, 0, (void*)0, 0};
|
26276
27332
|
|
26277
27333
|
static swig_type_info *swig_type_initial[] = {
|
@@ -26341,6 +27397,7 @@ static swig_type_info *swig_type_initial[] = {
|
|
26341
27397
|
&_swigt__p_u32_t,
|
26342
27398
|
&_swigt__p_u8_t,
|
26343
27399
|
&_swigt__p_uint_t,
|
27400
|
+
&_swigt__p_unsigned_int,
|
26344
27401
|
&_swigt__p_xyz_t,
|
26345
27402
|
};
|
26346
27403
|
|
@@ -26410,6 +27467,7 @@ static swig_cast_info _swigc__p_u16_t[] = { {&_swigt__p_u16_t, 0, 0, 0},{0, 0,
|
|
26410
27467
|
static swig_cast_info _swigc__p_u32_t[] = { {&_swigt__p_u32_t, 0, 0, 0},{0, 0, 0, 0}};
|
26411
27468
|
static swig_cast_info _swigc__p_u8_t[] = { {&_swigt__p_u8_t, 0, 0, 0},{0, 0, 0, 0}};
|
26412
27469
|
static swig_cast_info _swigc__p_uint_t[] = { {&_swigt__p_uint_t, 0, 0, 0},{0, 0, 0, 0}};
|
27470
|
+
static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
|
26413
27471
|
static swig_cast_info _swigc__p_xyz_t[] = { {&_swigt__p_xyz_t, 0, 0, 0},{0, 0, 0, 0}};
|
26414
27472
|
|
26415
27473
|
static swig_cast_info *swig_cast_initial[] = {
|
@@ -26479,6 +27537,7 @@ static swig_cast_info *swig_cast_initial[] = {
|
|
26479
27537
|
_swigc__p_u32_t,
|
26480
27538
|
_swigc__p_u8_t,
|
26481
27539
|
_swigc__p_uint_t,
|
27540
|
+
_swigc__p_unsigned_int,
|
26482
27541
|
_swigc__p_xyz_t,
|
26483
27542
|
};
|
26484
27543
|
|
@@ -26864,6 +27923,7 @@ SWIGEXPORT void Init_GPS(void) {
|
|
26864
27923
|
rb_define_method(SwigClassIonospheric_UTC_Parameters.klass, "delta_t_LSF=", VALUEFUNC(_wrap_Ionospheric_UTC_Parameters_delta_t_LSFe___), -1);
|
26865
27924
|
rb_define_method(SwigClassIonospheric_UTC_Parameters.klass, "delta_t_LSF", VALUEFUNC(_wrap_Ionospheric_UTC_Parameters_delta_t_LSF), -1);
|
26866
27925
|
rb_define_singleton_method(SwigClassIonospheric_UTC_Parameters.klass, "parse", VALUEFUNC(_wrap_Ionospheric_UTC_Parameters_parse), -1);
|
27926
|
+
rb_define_method(SwigClassIonospheric_UTC_Parameters.klass, "dump", VALUEFUNC(_wrap_Ionospheric_UTC_Parameters_dump), -1);
|
26867
27927
|
SwigClassIonospheric_UTC_Parameters.mark = 0;
|
26868
27928
|
SwigClassIonospheric_UTC_Parameters.destroy = (void (*)(void *)) free_GPS_Ionospheric_UTC_Parameters_Sl_double_Sg_;
|
26869
27929
|
SwigClassIonospheric_UTC_Parameters.trackObjects = 0;
|
@@ -26876,6 +27936,9 @@ SWIGEXPORT void Init_GPS(void) {
|
|
26876
27936
|
rb_define_method(SwigClassEphemeris.klass, "iode_subframe3", VALUEFUNC(_wrap_Ephemeris_iode_subframe3_get), -1);
|
26877
27937
|
rb_define_method(SwigClassEphemeris.klass, "invalidate", VALUEFUNC(_wrap_Ephemeris_invalidate), -1);
|
26878
27938
|
rb_define_method(SwigClassEphemeris.klass, "consistent?", VALUEFUNC(_wrap_Ephemeris_consistentq___), -1);
|
27939
|
+
rb_define_method(SwigClassEphemeris.klass, "valid?", VALUEFUNC(_wrap_Ephemeris_validq___), -1);
|
27940
|
+
rb_define_method(SwigClassEphemeris.klass, "t_clock", VALUEFUNC(_wrap_Ephemeris_t_clock), -1);
|
27941
|
+
rb_define_method(SwigClassEphemeris.klass, "t_ephemeris", VALUEFUNC(_wrap_Ephemeris_t_ephemeris), -1);
|
26879
27942
|
rb_define_method(SwigClassEphemeris.klass, "svid=", VALUEFUNC(_wrap_Ephemeris_svide___), -1);
|
26880
27943
|
rb_define_method(SwigClassEphemeris.klass, "svid", VALUEFUNC(_wrap_Ephemeris_svid), -1);
|
26881
27944
|
rb_define_method(SwigClassEphemeris.klass, "WN=", VALUEFUNC(_wrap_Ephemeris_WNe___), -1);
|
@@ -26933,6 +27996,9 @@ SWIGEXPORT void Init_GPS(void) {
|
|
26933
27996
|
rb_define_method(SwigClassEphemeris.klass, "dot_i0=", VALUEFUNC(_wrap_Ephemeris_dot_i0e___), -1);
|
26934
27997
|
rb_define_method(SwigClassEphemeris.klass, "dot_i0", VALUEFUNC(_wrap_Ephemeris_dot_i0), -1);
|
26935
27998
|
rb_define_method(SwigClassEphemeris.klass, "parse", VALUEFUNC(_wrap_Ephemeris_parse), -1);
|
27999
|
+
rb_define_method(SwigClassEphemeris.klass, "dump", VALUEFUNC(_wrap_Ephemeris_dump), -1);
|
28000
|
+
rb_define_method(SwigClassEphemeris.klass, "parse_almanac", VALUEFUNC(_wrap_Ephemeris_parse_almanac), -1);
|
28001
|
+
rb_define_method(SwigClassEphemeris.klass, "dump_almanac", VALUEFUNC(_wrap_Ephemeris_dump_almanac), -1);
|
26936
28002
|
rb_define_method(SwigClassEphemeris.klass, "constellation", VALUEFUNC(_wrap_Ephemeris_constellation), -1);
|
26937
28003
|
SwigClassEphemeris.mark = 0;
|
26938
28004
|
SwigClassEphemeris.destroy = (void (*)(void *)) free_GPS_Ephemeris_Sl_double_Sg_;
|
@@ -27056,6 +28122,8 @@ SWIGEXPORT void Init_GPS(void) {
|
|
27056
28122
|
SWIG_TypeClientData(SWIGTYPE_p_SBAS_EphemerisT_double_t, (void *) &SwigClassEphemeris_SBAS);
|
27057
28123
|
rb_define_alloc_func(SwigClassEphemeris_SBAS.klass, _wrap_Ephemeris_SBAS_allocate);
|
27058
28124
|
rb_define_method(SwigClassEphemeris_SBAS.klass, "initialize", VALUEFUNC(_wrap_new_Ephemeris_SBAS), -1);
|
28125
|
+
rb_define_method(SwigClassEphemeris_SBAS.klass, "valid?", VALUEFUNC(_wrap_Ephemeris_SBAS_validq___), -1);
|
28126
|
+
rb_define_method(SwigClassEphemeris_SBAS.klass, "t_applicable", VALUEFUNC(_wrap_Ephemeris_SBAS_t_applicable), -1);
|
27059
28127
|
rb_define_method(SwigClassEphemeris_SBAS.klass, "svid=", VALUEFUNC(_wrap_Ephemeris_SBAS_svide___), -1);
|
27060
28128
|
rb_define_method(SwigClassEphemeris_SBAS.klass, "svid", VALUEFUNC(_wrap_Ephemeris_SBAS_svid), -1);
|
27061
28129
|
rb_define_method(SwigClassEphemeris_SBAS.klass, "WN=", VALUEFUNC(_wrap_Ephemeris_SBAS_WNe___), -1);
|
@@ -27086,6 +28154,7 @@ SWIGEXPORT void Init_GPS(void) {
|
|
27086
28154
|
rb_define_method(SwigClassEphemeris_SBAS.klass, "a_Gf0", VALUEFUNC(_wrap_Ephemeris_SBAS_a_Gf0), -1);
|
27087
28155
|
rb_define_method(SwigClassEphemeris_SBAS.klass, "a_Gf1=", VALUEFUNC(_wrap_Ephemeris_SBAS_a_Gf1e___), -1);
|
27088
28156
|
rb_define_method(SwigClassEphemeris_SBAS.klass, "a_Gf1", VALUEFUNC(_wrap_Ephemeris_SBAS_a_Gf1), -1);
|
28157
|
+
rb_define_method(SwigClassEphemeris_SBAS.klass, "dump", VALUEFUNC(_wrap_Ephemeris_SBAS_dump), -1);
|
27089
28158
|
rb_define_method(SwigClassEphemeris_SBAS.klass, "constellation", VALUEFUNC(_wrap_Ephemeris_SBAS_constellation), -1);
|
27090
28159
|
SwigClassEphemeris_SBAS.mark = 0;
|
27091
28160
|
SwigClassEphemeris_SBAS.destroy = (void (*)(void *)) free_SBAS_Ephemeris_Sl_double_Sg_;
|
@@ -27173,6 +28242,7 @@ SWIGEXPORT void Init_GPS(void) {
|
|
27173
28242
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "raw", VALUEFUNC(_wrap_Ephemeris_GLONASS_raw_get), -1);
|
27174
28243
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "invalidate", VALUEFUNC(_wrap_Ephemeris_GLONASS_invalidate), -1);
|
27175
28244
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "consistent?", VALUEFUNC(_wrap_Ephemeris_GLONASS_consistentq___), -1);
|
28245
|
+
rb_define_method(SwigClassEphemeris_GLONASS.klass, "valid?", VALUEFUNC(_wrap_Ephemeris_GLONASS_validq___), -1);
|
27176
28246
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "svid=", VALUEFUNC(_wrap_Ephemeris_GLONASS_svide___), -1);
|
27177
28247
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "svid", VALUEFUNC(_wrap_Ephemeris_GLONASS_svid), -1);
|
27178
28248
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "freq_ch=", VALUEFUNC(_wrap_Ephemeris_GLONASS_freq_che___), -1);
|
@@ -27233,6 +28303,7 @@ SWIGEXPORT void Init_GPS(void) {
|
|
27233
28303
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "frequency_L2", VALUEFUNC(_wrap_Ephemeris_GLONASS_frequency_L2), -1);
|
27234
28304
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "base_time", VALUEFUNC(_wrap_Ephemeris_GLONASS_base_time), -1);
|
27235
28305
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "parse", VALUEFUNC(_wrap_Ephemeris_GLONASS_parse), -1);
|
28306
|
+
rb_define_method(SwigClassEphemeris_GLONASS.klass, "dump", VALUEFUNC(_wrap_Ephemeris_GLONASS_dump), -1);
|
27236
28307
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "constellation", VALUEFUNC(_wrap_Ephemeris_GLONASS_constellation), -1);
|
27237
28308
|
rb_define_method(SwigClassEphemeris_GLONASS.klass, "in_range?", VALUEFUNC(_wrap_Ephemeris_GLONASS_in_rangeq___), -1);
|
27238
28309
|
SwigClassEphemeris_GLONASS.mark = 0;
|