gps_pvt 0.2.0 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1889,12 +1889,12 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
1889
1889
  #define SWIGTYPE_p_llh_t swig_types[39]
1890
1890
  #define SWIGTYPE_p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t swig_types[40]
1891
1891
  #define SWIGTYPE_p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t swig_types[41]
1892
- #define SWIGTYPE_p_s16_t swig_types[42]
1893
- #define SWIGTYPE_p_s32_t swig_types[43]
1894
- #define SWIGTYPE_p_s8_t swig_types[44]
1895
- #define SWIGTYPE_p_satellites_t swig_types[45]
1896
- #define SWIGTYPE_p_self_t swig_types[46]
1897
- #define SWIGTYPE_p_std__vectorT_int_t swig_types[47]
1892
+ #define SWIGTYPE_p_range_correction_list_t swig_types[42]
1893
+ #define SWIGTYPE_p_s16_t swig_types[43]
1894
+ #define SWIGTYPE_p_s32_t swig_types[44]
1895
+ #define SWIGTYPE_p_s8_t swig_types[45]
1896
+ #define SWIGTYPE_p_satellites_t swig_types[46]
1897
+ #define SWIGTYPE_p_self_t swig_types[47]
1898
1898
  #define SWIGTYPE_p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t swig_types[48]
1899
1899
  #define SWIGTYPE_p_swig__GC_VALUE swig_types[49]
1900
1900
  #define SWIGTYPE_p_u16_t swig_types[50]
@@ -2465,6 +2465,7 @@ struct GPS_Measurement {
2465
2465
  L1_RANGE_RATE_SIGMA,
2466
2466
  L1_SIGNAL_STRENGTH_dBHz,
2467
2467
  L1_LOCK_SEC,
2468
+ L1_FREQUENCY,
2468
2469
  ITEMS_PREDEFINED,
2469
2470
  };
2470
2471
  void add(const int &prn, const int &key, const FloatT &value){
@@ -2475,43 +2476,8 @@ struct GPS_Measurement {
2475
2476
 
2476
2477
  template <class FloatT>
2477
2478
  struct GPS_SolverOptions_Common {
2478
- enum {
2479
- IONOSPHERIC_KLOBUCHAR,
2480
- IONOSPHERIC_SBAS,
2481
- IONOSPHERIC_NTCM_GL,
2482
- IONOSPHERIC_NONE, // which allows no correction
2483
- IONOSPHERIC_MODELS,
2484
- IONOSPHERIC_SKIP = IONOSPHERIC_MODELS, // which means delegating the next slot
2485
- };
2486
2479
  virtual GPS_Solver_GeneralOptions<FloatT> *cast_general() = 0;
2487
2480
  virtual const GPS_Solver_GeneralOptions<FloatT> *cast_general() const = 0;
2488
- std::vector<int> get_ionospheric_models() const {
2489
- typedef GPS_Solver_GeneralOptions<FloatT> general_t;
2490
- const general_t *general(this->cast_general());
2491
- std::vector<int> res;
2492
- for(int i(0); i < general_t::IONOSPHERIC_MODELS; ++i){
2493
- int v((int)(general->ionospheric_models[i]));
2494
- if(v == general_t::IONOSPHERIC_SKIP){break;}
2495
- res.push_back(v);
2496
- }
2497
- return res;
2498
- }
2499
- std::vector<int> set_ionospheric_models(const std::vector<int> &models){
2500
- typedef GPS_Solver_GeneralOptions<FloatT> general_t;
2501
- general_t *general(this->cast_general());
2502
- typedef typename general_t::ionospheric_model_t model_t;
2503
- for(int i(0), j(0), j_max(models.size()); i < general_t::IONOSPHERIC_MODELS; ++i){
2504
- model_t v(general_t::IONOSPHERIC_SKIP);
2505
- if(j < j_max){
2506
- if((models[j] >= 0) && (models[j] < general_t::IONOSPHERIC_SKIP)){
2507
- v = (model_t)models[j];
2508
- }
2509
- ++j;
2510
- }
2511
- general->ionospheric_models[i] = v;
2512
- }
2513
- return get_ionospheric_models();
2514
- }
2515
2481
  };
2516
2482
 
2517
2483
 
@@ -2541,6 +2507,26 @@ struct SBAS_SolverOptions
2541
2507
  };
2542
2508
 
2543
2509
 
2510
+ template <class FloatT>
2511
+ struct GPS_RangeCorrector
2512
+ : public GPS_Solver_Base<FloatT>::range_corrector_t {
2513
+ VALUE callback;
2514
+ GPS_RangeCorrector(const VALUE &callback_)
2515
+ : GPS_Solver_Base<FloatT>::range_corrector_t(),
2516
+ callback(callback_) {}
2517
+ bool is_available(const typename GPS_Solver_Base<FloatT>::gps_time_t &t) const {
2518
+ return false;
2519
+ }
2520
+ FloatT *calculate(
2521
+ const typename GPS_Solver_Base<FloatT>::gps_time_t &t,
2522
+ const typename GPS_Solver_Base<FloatT>::pos_t &usr_pos,
2523
+ const typename GPS_Solver_Base<FloatT>::enu_t &sat_rel_pos,
2524
+ FloatT &buf) const {
2525
+ return NULL;
2526
+ }
2527
+ };
2528
+
2529
+
2544
2530
  template <class FloatT>
2545
2531
  struct GPS_Solver
2546
2532
  : public GPS_Solver_RAIM_LSR<FloatT,
@@ -2561,19 +2547,36 @@ struct GPS_Solver
2561
2547
  sbas_t() : space_node(), options(), solver(space_node) {}
2562
2548
  } sbas;
2563
2549
  VALUE hooks;
2550
+ typedef std::vector<GPS_RangeCorrector<FloatT> > user_correctors_t;
2551
+ user_correctors_t user_correctors;
2564
2552
 
2565
2553
  static void mark(void *ptr){
2566
2554
  GPS_Solver<FloatT> *solver = (GPS_Solver<FloatT> *)ptr;
2567
- if(solver->hooks == Qnil){return;}
2568
2555
  rb_gc_mark(solver->hooks);
2556
+ for(typename user_correctors_t::const_iterator
2557
+ it(solver->user_correctors.begin()), it_end(solver->user_correctors.end());
2558
+ it != it_end; ++it){
2559
+ rb_gc_mark(it->callback);
2560
+ }
2569
2561
  }
2570
2562
 
2571
- GPS_Solver() : super_t(), gps(), sbas(), hooks() {
2572
- gps.solver.space_node_sbas = &sbas.space_node;
2573
- sbas.solver.space_node_gps = &gps.space_node;
2563
+ GPS_Solver() : super_t(),
2564
+ gps(), sbas(),
2565
+ hooks(), user_correctors() {
2574
2566
 
2575
2567
  hooks = rb_hash_new();
2576
2568
 
2569
+ typename base_t::range_correction_t ionospheric, tropospheric;
2570
+ ionospheric.push_back(&sbas.solver.ionospheric_sbas);
2571
+ ionospheric.push_back(&gps.solver.ionospheric_klobuchar);
2572
+ tropospheric.push_back(&sbas.solver.tropospheric_sbas);
2573
+ tropospheric.push_back(&gps.solver.tropospheric_simplified);
2574
+ gps.solver.ionospheric_correction
2575
+ = sbas.solver.ionospheric_correction
2576
+ = ionospheric;
2577
+ gps.solver.tropospheric_correction
2578
+ = sbas.solver.tropospheric_correction
2579
+ = tropospheric;
2577
2580
  }
2578
2581
  GPS_SpaceNode<FloatT> &gps_space_node() {return gps.space_node;}
2579
2582
  GPS_SolverOptions<FloatT> &gps_options() {return gps.options;}
@@ -2584,7 +2587,11 @@ struct GPS_Solver
2584
2587
  if(prn > 0 && prn <= 32){return gps.solver;}
2585
2588
  if(prn >= 120 && prn <= 158){return sbas.solver;}
2586
2589
  if(prn > 192 && prn <= 202){return gps.solver;}
2587
- return *this;
2590
+ // call order: base_t::solve => this returned by select()
2591
+ // => relative_property() => select_solver()
2592
+ // For not supported satellite, call loop prevention is required.
2593
+ static const base_t dummy;
2594
+ return dummy;
2588
2595
  }
2589
2596
  virtual typename base_t::relative_property_t relative_property(
2590
2597
  const typename base_t::prn_t &prn,
@@ -2596,9 +2603,7 @@ struct GPS_Solver
2596
2603
  virtual typename base_t::xyz_t *satellite_position(
2597
2604
  const typename base_t::prn_t &prn,
2598
2605
  const typename base_t::gps_time_t &time,
2599
- typename base_t::xyz_t &res) const {
2600
- return select_solver(prn).satellite_position(prn, time, res);
2601
- }
2606
+ typename base_t::xyz_t &res) const;
2602
2607
  virtual bool update_position_solution(
2603
2608
  const typename base_t::geometric_matrices_t &geomat,
2604
2609
  typename base_t::user_pvt_t &res) const;
@@ -2611,6 +2616,53 @@ struct GPS_Solver
2611
2616
  const_cast<sbas_t &>(sbas).solver.update_options(sbas.options);
2612
2617
  return super_t::solve().user_pvt(measurement.items, receiver_time);
2613
2618
  }
2619
+ typedef
2620
+ std::map<int, std::vector<const typename base_t::range_corrector_t *> >
2621
+ range_correction_list_t;
2622
+ range_correction_list_t update_correction(
2623
+ const bool &update,
2624
+ const range_correction_list_t &list = range_correction_list_t()){
2625
+ range_correction_list_t res;
2626
+ typename base_t::range_correction_t *root[] = {
2627
+ &gps.solver.ionospheric_correction,
2628
+ &gps.solver.tropospheric_correction,
2629
+ &sbas.solver.ionospheric_correction,
2630
+ &sbas.solver.tropospheric_correction,
2631
+ };
2632
+ for(std::size_t i(0); i < sizeof(root) / sizeof(root[0]); ++i){
2633
+ do{
2634
+ if(!update){break;}
2635
+ typename range_correction_list_t::const_iterator it(list.find(i));
2636
+ if(it == list.end()){break;}
2637
+
2638
+ // Remove user defined unused correctors
2639
+ for(typename base_t::range_correction_t::const_iterator
2640
+ it2(root[i]->begin()), it2_end(root[i]->end());
2641
+ it2 != it2_end; ++it2){
2642
+ for(typename user_correctors_t::const_iterator
2643
+ it3(user_correctors.begin()), it3_end(user_correctors.end());
2644
+ it3 != it3_end; ++it3){
2645
+ if(*it2 != &(*it3)){continue;}
2646
+ user_correctors.erase(it3);
2647
+ }
2648
+ }
2649
+
2650
+ root[i]->clear();
2651
+ for(typename range_correction_list_t::mapped_type::const_iterator
2652
+ it2(it->second.begin()), it2_end(it->second.end());
2653
+ it2 != it2_end; ++it2){
2654
+ root[i]->push_back(*it2);
2655
+ }
2656
+ }while(false);
2657
+ for(typename base_t::range_correction_t::const_iterator
2658
+ it(root[i]->begin()), it_end(root[i]->end());
2659
+ it != it_end; ++it){
2660
+ res[i].push_back(*it);
2661
+ }
2662
+ }
2663
+ return res;
2664
+ }
2665
+ VALUE update_correction(const bool &update, const VALUE &hash);
2614
2666
  };
2615
2667
 
2616
2668
 
@@ -2848,6 +2900,12 @@ SWIGINTERN void GPS_Time_Sl_double_Sg__to_a(GPS_Time< double > const *self,int *
2848
2900
  *week = self->week;
2849
2901
  *seconds = self->seconds;
2850
2902
  }
2903
+ SWIGINTERN int GPS_Time_Sl_double_Sg____cmp__(GPS_Time< double > const *self,GPS_Time< double > const &t){
2904
+ return ((self->week < t.week) ? -1
2905
+ : ((self->week > t.week) ? 1
2906
+ : (self->seconds < t.seconds ? -1
2907
+ : (self->seconds > t.seconds ? 1 : 0))));
2908
+ }
2851
2909
 
2852
2910
  namespace swig {
2853
2911
  template <class Type>
@@ -3200,11 +3258,8 @@ SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
3200
3258
 
3201
3259
  SWIGINTERN int GPS_SpaceNode_Sl_double_Sg__read(GPS_SpaceNode< double > *self,char const *fname){
3202
3260
  std::fstream fin(fname, std::ios::in | std::ios::binary);
3203
- typename RINEX_NAV_Reader<double>::space_node_list_t space_nodes = {
3204
- self, // GPS
3205
- NULL, // SBAS
3206
- self, // QZSS
3207
- };
3261
+ typename RINEX_NAV_Reader<double>::space_node_list_t space_nodes = {self};
3262
+ space_nodes.qzss = self;
3208
3263
  return RINEX_NAV_Reader<double>::read_all(fin, space_nodes);
3209
3264
  }
3210
3265
  SWIGINTERN void GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__set_alpha(GPS_Ionospheric_UTC_Parameters< double > *self,double const values[4]){
@@ -3593,6 +3648,18 @@ SWIGINTERN void GPS_Ephemeris_Sl_double_Sg__constellation__SWIG_0(GPS_Ephemeris<
3593
3648
 
3594
3649
  return SWIG_ERROR;
3595
3650
  }
3651
+
3652
+ template <>
3653
+ VALUE from(const GPS_Measurement<double>::items_t::mapped_type &val) {
3654
+ VALUE per_sat(rb_hash_new());
3655
+ for(typename GPS_Measurement<double>::items_t::mapped_type::const_iterator
3656
+ it(val.begin()), it_end(val.end());
3657
+ it != it_end; ++it){
3658
+ rb_hash_aset(per_sat, SWIG_From_int (it->first), swig::from(it->second));
3659
+ }
3660
+ return per_sat;
3661
+ }
3662
+
3596
3663
  }
3597
3664
 
3598
3665
  SWIGINTERN void GPS_Measurement_Sl_double_Sg__each(GPS_Measurement< double > const *self){
@@ -3618,13 +3685,7 @@ SWIGINTERN VALUE GPS_Measurement_Sl_double_Sg__to_hash(GPS_Measurement< double >
3618
3685
  for(typename GPS_Measurement<double>::items_t::const_iterator
3619
3686
  it(self->items.begin()), it_end(self->items.end());
3620
3687
  it != it_end; ++it){
3621
- VALUE per_sat(rb_hash_new());
3622
- rb_hash_aset(res, SWIG_From_int (it->first), per_sat);
3623
- for(typename GPS_Measurement<double>::items_t::mapped_type::const_iterator
3624
- it2(it->second.begin()), it2_end(it->second.end());
3625
- it2 != it2_end; ++it2){
3626
- rb_hash_aset(per_sat, SWIG_From_int (it2->first), swig::from(it2->second));
3627
- }
3688
+ rb_hash_aset(res, SWIG_From_int (it->first), swig::from(it->second));
3628
3689
  }
3629
3690
  return res;
3630
3691
  }
@@ -3640,24 +3701,18 @@ SWIGINTERN double GPS_SolverOptions_Common_Sl_double_Sg__set_residual_mask(GPS_S
3640
3701
  SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_residual_mask(GPS_SolverOptions_Common< double > const *self){
3641
3702
  return self->cast_general()->residual_mask;
3642
3703
  }
3643
- SWIGINTERN double GPS_SolverOptions_Common_Sl_double_Sg__set_f_10_7(GPS_SolverOptions_Common< double > *self,double const &v){
3644
- return self->cast_general()->f_10_7 = v;
3645
- }
3646
- SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_f_10_7(GPS_SolverOptions_Common< double > const *self){
3647
- return self->cast_general()->f_10_7;
3648
- }
3649
3704
 
3650
3705
  template <>
3651
- typename GPS_Solver<double>::base_t::relative_property_t
3706
+ GPS_Solver<double>::base_t::relative_property_t
3652
3707
  GPS_Solver<double>::relative_property(
3653
- const typename GPS_Solver<double>::base_t::prn_t &prn,
3654
- const typename GPS_Solver<double>::base_t::measurement_t::mapped_type &measurement,
3655
- const typename GPS_Solver<double>::base_t::float_t &receiver_error,
3656
- const typename GPS_Solver<double>::base_t::gps_time_t &time_arrival,
3657
- const typename GPS_Solver<double>::base_t::pos_t &usr_pos,
3658
- const typename GPS_Solver<double>::base_t::xyz_t &usr_vel) const {
3708
+ const GPS_Solver<double>::base_t::prn_t &prn,
3709
+ const GPS_Solver<double>::base_t::measurement_t::mapped_type &measurement,
3710
+ const GPS_Solver<double>::base_t::float_t &receiver_error,
3711
+ const GPS_Solver<double>::base_t::gps_time_t &time_arrival,
3712
+ const GPS_Solver<double>::base_t::pos_t &usr_pos,
3713
+ const GPS_Solver<double>::base_t::xyz_t &usr_vel) const {
3659
3714
  union {
3660
- typename base_t::relative_property_t prop;
3715
+ base_t::relative_property_t prop;
3661
3716
  double values[7];
3662
3717
  } res = {
3663
3718
  select_solver(prn).relative_property(
@@ -3679,6 +3734,7 @@ SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_f_10_7(GPS_S
3679
3734
  swig::from(res.prop.los_neg[0]),
3680
3735
  swig::from(res.prop.los_neg[1]),
3681
3736
  swig::from(res.prop.los_neg[2])),
3737
+ swig::from(measurement), // measurement => Hash
3682
3738
  swig::from(receiver_error), // receiver_error
3683
3739
  SWIG_NewPointerObj( // time_arrival
3684
3740
  new base_t::gps_time_t(time_arrival), SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_OWN),
@@ -3709,28 +3765,213 @@ SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_f_10_7(GPS_S
3709
3765
  }
3710
3766
  template <>
3711
3767
  bool GPS_Solver<double>::update_position_solution(
3712
- const typename GPS_Solver<double>::base_t::geometric_matrices_t &geomat,
3713
- typename GPS_Solver<double>::base_t::user_pvt_t &res) const {
3768
+ const GPS_Solver<double>::base_t::geometric_matrices_t &geomat,
3769
+ GPS_Solver<double>::base_t::user_pvt_t &res) const {
3714
3770
 
3715
3771
  do{
3716
3772
  static const VALUE key(ID2SYM(rb_intern("update_position_solution")));
3717
3773
  VALUE hook(rb_hash_lookup(hooks, key));
3718
3774
  if(NIL_P(hook)){break;}
3719
- typename base_t::geometric_matrices_t &geomat_(
3720
- const_cast< typename base_t::geometric_matrices_t & >(geomat));
3775
+ base_t::geometric_matrices_t &geomat_(
3776
+ const_cast< base_t::geometric_matrices_t & >(geomat));
3721
3777
  VALUE values[] = {
3722
3778
  SWIG_NewPointerObj(&geomat_.G,
3723
3779
  SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0),
3724
3780
  SWIG_NewPointerObj(&geomat_.W,
3725
3781
  SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0),
3726
3782
  SWIG_NewPointerObj(&geomat_.delta_r,
3727
- SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0)};
3783
+ SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0),
3784
+ SWIG_NewPointerObj(&res,
3785
+ SWIGTYPE_p_GPS_User_PVTT_double_t, 0)};
3728
3786
  proc_call_throw_if_error(hook, sizeof(values) / sizeof(values[0]), values);
3729
3787
  }while(false);
3730
3788
 
3731
3789
  return super_t::update_position_solution(geomat, res);
3732
3790
  }
3791
+ template <>
3792
+ GPS_Solver<double>::base_t::xyz_t *GPS_Solver<double>::satellite_position(
3793
+ const GPS_Solver<double>::base_t::prn_t &prn,
3794
+ const GPS_Solver<double>::base_t::gps_time_t &time,
3795
+ GPS_Solver<double>::base_t::xyz_t &buf) const {
3796
+ GPS_Solver<double>::base_t::xyz_t *res(
3797
+ select_solver(prn).satellite_position(prn, time, buf));
3798
+
3799
+ do{
3800
+ static const VALUE key(ID2SYM(rb_intern("satellite_position")));
3801
+ VALUE hook(rb_hash_lookup(hooks, key));
3802
+ if(NIL_P(hook)){break;}
3803
+ VALUE values[] = {
3804
+ SWIG_From_int (prn), // prn
3805
+ SWIG_NewPointerObj( // time
3806
+ new base_t::gps_time_t(time), SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_OWN),
3807
+ (res // position (internally calculated)
3808
+ ? SWIG_NewPointerObj(res, SWIGTYPE_p_System_XYZT_double_WGS84_t, 0)
3809
+ : Qnil)};
3810
+ VALUE res_hook(proc_call_throw_if_error(hook, sizeof(values) / sizeof(values[0]), values));
3811
+ if(NIL_P(res_hook)){ // unknown position
3812
+ res = NULL;
3813
+ break;
3814
+ }else if(RB_TYPE_P(res_hook, T_ARRAY) && (RARRAY_LEN(res_hook) == 3)){
3815
+ int i(0);
3816
+ for(; i < 3; ++i){
3817
+ VALUE v(RARRAY_AREF(res_hook, i));
3818
+ if(!SWIG_IsOK(swig::asval(v, &buf[i]))){break;}
3819
+ }
3820
+ if(i == 3){
3821
+ res = &buf;
3822
+ break;
3823
+ }
3824
+ }else if(SWIG_IsOK(SWIG_ConvertPtr(
3825
+ res_hook, (void **)&res, SWIGTYPE_p_System_XYZT_double_WGS84_t, 0))){
3826
+ res = &(buf = *res);
3827
+ break;
3828
+ }
3829
+ throw std::runtime_error(
3830
+ std::string("System_XYZ or [d * 3] is expected (d: " "double" "), however ")
3831
+ .append(inspect_str(res_hook)));
3832
+ }while(false);
3833
+
3834
+ return res;
3835
+ }
3836
+
3837
+
3838
+ template <>
3839
+ bool GPS_RangeCorrector<double>::is_available(
3840
+ const typename GPS_Solver_Base<double>::gps_time_t &t) const {
3841
+ VALUE values[] = {
3842
+ SWIG_NewPointerObj(
3843
+ const_cast< GPS_Time<double> * >(&t), SWIGTYPE_p_GPS_TimeT_double_t, 0),
3844
+ };
3845
+ VALUE res(proc_call_throw_if_error(
3846
+ callback, sizeof(values) / sizeof(values[0]), values));
3847
+ return RTEST(res) ? true : false;
3848
+ }
3849
+ template <>
3850
+ double *GPS_RangeCorrector<double>::calculate(
3851
+ const typename GPS_Solver_Base<double>::gps_time_t &t,
3852
+ const typename GPS_Solver_Base<double>::pos_t &usr_pos,
3853
+ const typename GPS_Solver_Base<double>::enu_t &sat_rel_pos,
3854
+ double &buf) const {
3855
+ VALUE values[] = {
3856
+ SWIG_NewPointerObj(
3857
+ const_cast< GPS_Time<double> * >(&t),
3858
+ SWIGTYPE_p_GPS_TimeT_double_t, 0),
3859
+ SWIG_NewPointerObj(
3860
+ (const_cast< System_XYZ<double,WGS84> * >(&usr_pos.xyz)),
3861
+ SWIGTYPE_p_System_XYZT_double_WGS84_t, 0),
3862
+ SWIG_NewPointerObj(
3863
+ (const_cast< System_ENU<double,WGS84> * >(&sat_rel_pos)),
3864
+ SWIGTYPE_p_System_ENUT_double_WGS84_t, 0),
3865
+ };
3866
+ VALUE res(proc_call_throw_if_error(
3867
+ callback, sizeof(values) / sizeof(values[0]), values));
3868
+ return SWIG_IsOK(swig::asval(res, &buf)) ? &buf : NULL;
3869
+ }
3870
+ template<>
3871
+ VALUE GPS_Solver<double>::update_correction(
3872
+ const bool &update, const VALUE &hash){
3873
+ typedef range_correction_list_t list_t;
3874
+ static const VALUE k_root[] = {
3875
+ ID2SYM(rb_intern("gps_ionospheric")),
3876
+ ID2SYM(rb_intern("gps_tropospheric")),
3877
+ ID2SYM(rb_intern("sbas_ionospheric")),
3878
+ ID2SYM(rb_intern("sbas_tropospheric")),
3879
+ };
3880
+ static const VALUE k_opt(ID2SYM(rb_intern("options")));
3881
+ static const VALUE k_f_10_7(ID2SYM(rb_intern("f_10_7")));
3882
+ static const VALUE k_known(ID2SYM(rb_intern("known")));
3883
+ struct {
3884
+ VALUE sym;
3885
+ list_t::mapped_type::value_type obj;
3886
+ } item[] = {
3887
+ {ID2SYM(rb_intern("no_correction")), &base_t::no_correction},
3888
+ {ID2SYM(rb_intern("klobuchar")), &this->gps.solver.ionospheric_klobuchar},
3889
+ {ID2SYM(rb_intern("ntcm_gl")), &this->gps.solver.ionospheric_ntcm_gl},
3890
+ {ID2SYM(rb_intern("hopfield")), &this->gps.solver.tropospheric_simplified},
3891
+ {ID2SYM(rb_intern("sbas_igp")), &this->sbas.solver.ionospheric_sbas},
3892
+ {ID2SYM(rb_intern("sbas_tropo")), &this->sbas.solver.tropospheric_sbas},
3893
+ };
3894
+ list_t input;
3895
+ if(update){
3896
+ if(!RB_TYPE_P(hash, T_HASH)){
3897
+ throw std::runtime_error(
3898
+ std::string("Hash is expected, however ").append(inspect_str(hash)));
3899
+ }
3900
+ for(std::size_t i(0); i < sizeof(k_root) / sizeof(k_root[0]); ++i){
3901
+ VALUE ary = rb_hash_lookup(hash, k_root[i]);
3902
+ if(NIL_P(ary)){continue;}
3903
+ if(!RB_TYPE_P(ary, T_ARRAY)){
3904
+ ary = rb_ary_new_from_values(1, &ary);
3905
+ }
3906
+ for(int j(0); j < RARRAY_LEN(ary); ++j){
3907
+ std::size_t k(0);
3908
+ VALUE v(rb_ary_entry(ary, j));
3909
+ for(; k < sizeof(item) / sizeof(item[0]); ++k){
3910
+ if(v == item[k].sym){break;}
3911
+ }
3912
+ if(k >= sizeof(item) / sizeof(item[0])){ // other than symbol
3913
+ user_correctors.push_back(GPS_RangeCorrector<double>(v));
3914
+ input[i].push_back(&user_correctors.back());
3915
+ }else{
3916
+ input[i].push_back(item[k].obj);
3917
+ }
3918
+ }
3919
+ }
3920
+ VALUE opt(rb_hash_lookup(hash, k_opt));
3921
+ if(RB_TYPE_P(opt, T_HASH)){
3922
+ swig::asval(rb_hash_lookup(opt, k_f_10_7), // ntcm_gl
3923
+ &this->gps.solver.ionospheric_ntcm_gl.f_10_7);
3924
+ }
3925
+ }
3926
+ list_t output(update_correction(update, input));
3927
+ VALUE res = rb_hash_new();
3928
+ for(list_t::const_iterator it(output.begin()), it_end(output.end());
3929
+ it != it_end; ++it){
3930
+ VALUE k;
3931
+ if((it->first < 0) || (it->first >= (int)(sizeof(k_root) / sizeof(k_root[0])))){
3932
+ k = SWIG_From_int (it->first);
3933
+ }else{
3934
+ k = k_root[it->first];
3935
+ }
3936
+ VALUE v = rb_ary_new();
3937
+ for(list_t::mapped_type::const_iterator
3938
+ it2(it->second.begin()), it2_end(it->second.end());
3939
+ it2 != it2_end; ++it2){
3940
+ std::size_t i(0);
3941
+ for(; i < sizeof(item) / sizeof(item[0]); ++i){
3942
+ if(*it2 == item[i].obj){break;}
3943
+ }
3944
+ if(i >= sizeof(item) / sizeof(item[0])){ // other than built-in corrector
3945
+ rb_ary_push(v,
3946
+ reinterpret_cast<const GPS_RangeCorrector<double> *>(*it2)->callback);
3947
+ }else{
3948
+ rb_ary_push(v, item[i].sym);
3949
+ }
3950
+ }
3951
+ rb_hash_aset(res, k, v);
3952
+ }
3953
+ { // common options
3954
+ VALUE opt = rb_hash_new();
3955
+ rb_hash_aset(res, k_opt, opt);
3956
+ rb_hash_aset(opt, k_f_10_7, // ntcm_gl
3957
+ swig::from(this->gps.solver.ionospheric_ntcm_gl.f_10_7));
3958
+ }
3959
+ { // known models
3960
+ VALUE ary = rb_ary_new_capa((int)(sizeof(item) / sizeof(item[0])));
3961
+ for(std::size_t i(0); i < sizeof(item) / sizeof(item[0]); ++i){
3962
+ rb_ary_push(ary, item[i].sym);
3963
+ }
3964
+ rb_hash_aset(res, k_known, ary);
3965
+ }
3966
+ return res;
3967
+ }
3733
3968
 
3969
+ SWIGINTERN VALUE GPS_Solver_Sl_double_Sg__get_correction(GPS_Solver< double > const *self){
3970
+ return const_cast<GPS_Solver<double> *>(self)->update_correction(false, Qnil);
3971
+ }
3972
+ SWIGINTERN VALUE GPS_Solver_Sl_double_Sg__set_correction(GPS_Solver< double > *self,VALUE hash){
3973
+ return self->update_correction(true, hash);
3974
+ }
3734
3975
  SWIGINTERN unsigned int SBAS_Ephemeris_Sl_double_Sg__set_svid(SBAS_Ephemeris< double > *self,unsigned int const &v){
3735
3976
  return self->svid = v;
3736
3977
  }
@@ -3836,7 +4077,8 @@ SWIGINTERN SBAS_Ephemeris< double > SBAS_SpaceNode_Sl_double_Sg__ephemeris(SBAS_
3836
4077
  }
3837
4078
  SWIGINTERN int SBAS_SpaceNode_Sl_double_Sg__read(SBAS_SpaceNode< double > *self,char const *fname){
3838
4079
  std::fstream fin(fname, std::ios::in | std::ios::binary);
3839
- RINEX_NAV_Reader<double>::space_node_list_t space_nodes = {NULL, self};
4080
+ RINEX_NAV_Reader<double>::space_node_list_t space_nodes = {NULL};
4081
+ space_nodes.sbas = self;
3840
4082
  return RINEX_NAV_Reader<double>::read_all(fin, space_nodes);
3841
4083
  }
3842
4084
  SWIGINTERN int SBAS_SpaceNode_Sl_double_Sg__decode_message__SWIG_2(SBAS_SpaceNode< double > *self,unsigned int const buf[8],int const &prn,GPS_Time< double > const &t_reception,bool const &LNAV_VNAV_LP_LPV_approach=false){
@@ -6052,6 +6294,58 @@ fail:
6052
6294
  }
6053
6295
 
6054
6296
 
6297
+ /*
6298
+ Document-method: GPS_PVT::GPS::Time.<=>
6299
+
6300
+ call-seq:
6301
+ <=>(t) -> int
6302
+
6303
+ Comparison operator. Returns < 0 for less than, 0 for equal or > 1 for higher than..
6304
+ */
6305
+ SWIGINTERN VALUE
6306
+ _wrap_Time___cmp__(int argc, VALUE *argv, VALUE self) {
6307
+ GPS_Time< double > *arg1 = (GPS_Time< double > *) 0 ;
6308
+ GPS_Time< double > *arg2 = 0 ;
6309
+ void *argp1 = 0 ;
6310
+ int res1 = 0 ;
6311
+ void *argp2 ;
6312
+ int res2 = 0 ;
6313
+ int result;
6314
+ VALUE vresult = Qnil;
6315
+
6316
+ if ((argc < 1) || (argc > 1)) {
6317
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6318
+ }
6319
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_TimeT_double_t, 0 | 0 );
6320
+ if (!SWIG_IsOK(res1)) {
6321
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Time< double > const *","__cmp__", 1, self ));
6322
+ }
6323
+ arg1 = reinterpret_cast< GPS_Time< double > * >(argp1);
6324
+ res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
6325
+ if (!SWIG_IsOK(res2)) {
6326
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_Time< double > const &","__cmp__", 2, argv[0] ));
6327
+ }
6328
+ if (!argp2) {
6329
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","__cmp__", 2, argv[0]));
6330
+ }
6331
+ arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
6332
+ {
6333
+ try {
6334
+ result = (int)GPS_Time_Sl_double_Sg____cmp__((GPS_Time< double > const *)arg1,(GPS_Time< double > const &)*arg2);
6335
+ } catch (const native_exception &e) {
6336
+ e.regenerate();
6337
+ SWIG_fail;
6338
+ } catch (const std::exception& e) {
6339
+ SWIG_exception_fail(SWIG_RuntimeError, e.what());
6340
+ }
6341
+ }
6342
+ vresult = SWIG_From_int(static_cast< int >(result));
6343
+ return vresult;
6344
+ fail:
6345
+ return Qnil;
6346
+ }
6347
+
6348
+
6055
6349
  SWIGINTERN void
6056
6350
  free_GPS_Time_Sl_double_Sg_(void *self) {
6057
6351
  GPS_Time< double > *arg1 = (GPS_Time< double > *)self;
@@ -6270,6 +6564,50 @@ _wrap_SpaceNode_gamma_L1_L2_get(VALUE self) {
6270
6564
  }
6271
6565
 
6272
6566
 
6567
+ /*
6568
+ Document-method: GPS_PVT::GPS::SpaceNode.gamma_per_L1
6569
+
6570
+ call-seq:
6571
+ gamma_per_L1(GPS_SpaceNode< double >::float_t const & freq) -> GPS_SpaceNode< double >::float_t const
6572
+
6573
+ A class method.
6574
+
6575
+ */
6576
+ SWIGINTERN VALUE
6577
+ _wrap_SpaceNode_gamma_per_L1(int argc, VALUE *argv, VALUE self) {
6578
+ GPS_SpaceNode< double >::float_t *arg1 = 0 ;
6579
+ GPS_SpaceNode< double >::float_t temp1 ;
6580
+ double val1 ;
6581
+ int ecode1 = 0 ;
6582
+ GPS_SpaceNode< double >::float_t result;
6583
+ VALUE vresult = Qnil;
6584
+
6585
+ if ((argc < 1) || (argc > 1)) {
6586
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6587
+ }
6588
+ ecode1 = SWIG_AsVal_double(argv[0], &val1);
6589
+ if (!SWIG_IsOK(ecode1)) {
6590
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::float_t","GPS_SpaceNode<(double)>::gamma_per_L1", 1, argv[0] ));
6591
+ }
6592
+ temp1 = static_cast< GPS_SpaceNode< double >::float_t >(val1);
6593
+ arg1 = &temp1;
6594
+ {
6595
+ try {
6596
+ result = (GPS_SpaceNode< double >::float_t)GPS_SpaceNode< double >::SWIGTEMPLATEDISAMBIGUATOR gamma_per_L1((double const &)*arg1);
6597
+ } catch (const native_exception &e) {
6598
+ e.regenerate();
6599
+ SWIG_fail;
6600
+ } catch (const std::exception& e) {
6601
+ SWIG_exception_fail(SWIG_RuntimeError, e.what());
6602
+ }
6603
+ }
6604
+ vresult = SWIG_From_double(static_cast< double >(result));
6605
+ return vresult;
6606
+ fail:
6607
+ return Qnil;
6608
+ }
6609
+
6610
+
6273
6611
  SWIGINTERN VALUE
6274
6612
  #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
6275
6613
  _wrap_SpaceNode_allocate(VALUE self)
@@ -7695,50 +8033,42 @@ fail:
7695
8033
  tropo_correction(ENU relative_pos, LLH usrllh) -> GPS_SpaceNode< double >::float_t
7696
8034
  tropo_correction(XYZ sat, XYZ usr) -> GPS_SpaceNode< double >::float_t
7697
8035
 
7698
- An instance method.
8036
+ A class method.
7699
8037
 
7700
8038
  */
7701
8039
  SWIGINTERN VALUE
7702
8040
  _wrap_SpaceNode_tropo_correction__SWIG_0(int argc, VALUE *argv, VALUE self) {
7703
- GPS_SpaceNode< double > *arg1 = (GPS_SpaceNode< double > *) 0 ;
7704
- GPS_SpaceNode< double >::enu_t *arg2 = 0 ;
7705
- GPS_SpaceNode< double >::llh_t *arg3 = 0 ;
7706
- void *argp1 = 0 ;
8041
+ GPS_SpaceNode< double >::enu_t *arg1 = 0 ;
8042
+ GPS_SpaceNode< double >::llh_t *arg2 = 0 ;
8043
+ void *argp1 ;
7707
8044
  int res1 = 0 ;
7708
8045
  void *argp2 ;
7709
8046
  int res2 = 0 ;
7710
- void *argp3 ;
7711
- int res3 = 0 ;
7712
8047
  GPS_SpaceNode< double >::float_t result;
7713
8048
  VALUE vresult = Qnil;
7714
8049
 
7715
8050
  if ((argc < 2) || (argc > 2)) {
7716
8051
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
7717
8052
  }
7718
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SpaceNodeT_double_t, 0 | 0 );
8053
+ res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_System_ENUT_double_WGS84_t, 0 );
7719
8054
  if (!SWIG_IsOK(res1)) {
7720
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SpaceNode< double > const *","tropo_correction", 1, self ));
8055
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::enu_t const &","GPS_SpaceNode<(double)>::tropo_correction", 1, argv[0] ));
7721
8056
  }
7722
- arg1 = reinterpret_cast< GPS_SpaceNode< double > * >(argp1);
7723
- res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_System_ENUT_double_WGS84_t, 0 );
8057
+ if (!argp1) {
8058
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_SpaceNode< double >::enu_t const &","GPS_SpaceNode<(double)>::tropo_correction", 1, argv[0]));
8059
+ }
8060
+ arg1 = reinterpret_cast< GPS_SpaceNode< double >::enu_t * >(argp1);
8061
+ res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_System_LLHT_double_WGS84_t, 0 );
7724
8062
  if (!SWIG_IsOK(res2)) {
7725
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::enu_t const &","tropo_correction", 2, argv[0] ));
8063
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::llh_t const &","GPS_SpaceNode<(double)>::tropo_correction", 2, argv[1] ));
7726
8064
  }
7727
8065
  if (!argp2) {
7728
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_SpaceNode< double >::enu_t const &","tropo_correction", 2, argv[0]));
7729
- }
7730
- arg2 = reinterpret_cast< GPS_SpaceNode< double >::enu_t * >(argp2);
7731
- res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_System_LLHT_double_WGS84_t, 0 );
7732
- if (!SWIG_IsOK(res3)) {
7733
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::llh_t const &","tropo_correction", 3, argv[1] ));
7734
- }
7735
- if (!argp3) {
7736
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_SpaceNode< double >::llh_t const &","tropo_correction", 3, argv[1]));
8066
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_SpaceNode< double >::llh_t const &","GPS_SpaceNode<(double)>::tropo_correction", 2, argv[1]));
7737
8067
  }
7738
- arg3 = reinterpret_cast< GPS_SpaceNode< double >::llh_t * >(argp3);
8068
+ arg2 = reinterpret_cast< GPS_SpaceNode< double >::llh_t * >(argp2);
7739
8069
  {
7740
8070
  try {
7741
- result = (GPS_SpaceNode< double >::float_t)((GPS_SpaceNode< double > const *)arg1)->tropo_correction((GPS_SpaceNode< double >::enu_t const &)*arg2,(GPS_SpaceNode< double >::llh_t const &)*arg3);
8071
+ result = (GPS_SpaceNode< double >::float_t)GPS_SpaceNode< double >::SWIGTEMPLATEDISAMBIGUATOR tropo_correction((System_ENU< double,WGS84 > const &)*arg1,(System_LLH< double,WGS84 > const &)*arg2);
7742
8072
  } catch (const native_exception &e) {
7743
8073
  e.regenerate();
7744
8074
  SWIG_fail;
@@ -7825,50 +8155,42 @@ fail:
7825
8155
  tropo_correction(ENU relative_pos, LLH usrllh) -> GPS_SpaceNode< double >::float_t
7826
8156
  tropo_correction(XYZ sat, XYZ usr) -> GPS_SpaceNode< double >::float_t
7827
8157
 
7828
- An instance method.
8158
+ A class method.
7829
8159
 
7830
8160
  */
7831
8161
  SWIGINTERN VALUE
7832
8162
  _wrap_SpaceNode_tropo_correction__SWIG_1(int argc, VALUE *argv, VALUE self) {
7833
- GPS_SpaceNode< double > *arg1 = (GPS_SpaceNode< double > *) 0 ;
8163
+ GPS_SpaceNode< double >::xyz_t *arg1 = 0 ;
7834
8164
  GPS_SpaceNode< double >::xyz_t *arg2 = 0 ;
7835
- GPS_SpaceNode< double >::xyz_t *arg3 = 0 ;
7836
- void *argp1 = 0 ;
8165
+ void *argp1 ;
7837
8166
  int res1 = 0 ;
7838
8167
  void *argp2 ;
7839
8168
  int res2 = 0 ;
7840
- void *argp3 ;
7841
- int res3 = 0 ;
7842
8169
  GPS_SpaceNode< double >::float_t result;
7843
8170
  VALUE vresult = Qnil;
7844
8171
 
7845
8172
  if ((argc < 2) || (argc > 2)) {
7846
8173
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
7847
8174
  }
7848
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SpaceNodeT_double_t, 0 | 0 );
8175
+ res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_System_XYZT_double_WGS84_t, 0 );
7849
8176
  if (!SWIG_IsOK(res1)) {
7850
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SpaceNode< double > const *","tropo_correction", 1, self ));
8177
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::xyz_t const &","GPS_SpaceNode<(double)>::tropo_correction", 1, argv[0] ));
7851
8178
  }
7852
- arg1 = reinterpret_cast< GPS_SpaceNode< double > * >(argp1);
7853
- res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_System_XYZT_double_WGS84_t, 0 );
8179
+ if (!argp1) {
8180
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_SpaceNode< double >::xyz_t const &","GPS_SpaceNode<(double)>::tropo_correction", 1, argv[0]));
8181
+ }
8182
+ arg1 = reinterpret_cast< GPS_SpaceNode< double >::xyz_t * >(argp1);
8183
+ res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_System_XYZT_double_WGS84_t, 0 );
7854
8184
  if (!SWIG_IsOK(res2)) {
7855
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::xyz_t const &","tropo_correction", 2, argv[0] ));
8185
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::xyz_t const &","GPS_SpaceNode<(double)>::tropo_correction", 2, argv[1] ));
7856
8186
  }
7857
8187
  if (!argp2) {
7858
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_SpaceNode< double >::xyz_t const &","tropo_correction", 2, argv[0]));
8188
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_SpaceNode< double >::xyz_t const &","GPS_SpaceNode<(double)>::tropo_correction", 2, argv[1]));
7859
8189
  }
7860
8190
  arg2 = reinterpret_cast< GPS_SpaceNode< double >::xyz_t * >(argp2);
7861
- res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_System_XYZT_double_WGS84_t, 0 );
7862
- if (!SWIG_IsOK(res3)) {
7863
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::xyz_t const &","tropo_correction", 3, argv[1] ));
7864
- }
7865
- if (!argp3) {
7866
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_SpaceNode< double >::xyz_t const &","tropo_correction", 3, argv[1]));
7867
- }
7868
- arg3 = reinterpret_cast< GPS_SpaceNode< double >::xyz_t * >(argp3);
7869
8191
  {
7870
8192
  try {
7871
- result = (GPS_SpaceNode< double >::float_t)((GPS_SpaceNode< double > const *)arg1)->tropo_correction((GPS_SpaceNode< double >::xyz_t const &)*arg2,(GPS_SpaceNode< double >::xyz_t const &)*arg3);
8193
+ result = (GPS_SpaceNode< double >::float_t)GPS_SpaceNode< double >::SWIGTEMPLATEDISAMBIGUATOR tropo_correction((System_XYZ< double,WGS84 > const &)*arg1,(System_XYZ< double,WGS84 > const &)*arg2);
7872
8194
  } catch (const native_exception &e) {
7873
8195
  e.regenerate();
7874
8196
  SWIG_fail;
@@ -7885,56 +8207,45 @@ fail:
7885
8207
 
7886
8208
  SWIGINTERN VALUE _wrap_SpaceNode_tropo_correction(int nargs, VALUE *args, VALUE self) {
7887
8209
  int argc;
7888
- VALUE argv[4];
8210
+ VALUE argv[2];
7889
8211
  int ii;
7890
8212
 
7891
- argc = nargs + 1;
7892
- argv[0] = self;
7893
- if (argc > 4) SWIG_fail;
7894
- for (ii = 1; (ii < argc); ++ii) {
7895
- argv[ii] = args[ii-1];
8213
+ argc = nargs;
8214
+ if (argc > 2) SWIG_fail;
8215
+ for (ii = 0; (ii < argc); ++ii) {
8216
+ argv[ii] = args[ii];
7896
8217
  }
7897
- if (argc == 3) {
8218
+ if (argc == 2) {
7898
8219
  int _v;
7899
8220
  void *vptr = 0;
7900
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_SpaceNodeT_double_t, 0);
8221
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_System_ENUT_double_WGS84_t, SWIG_POINTER_NO_NULL);
7901
8222
  _v = SWIG_CheckState(res);
7902
8223
  if (_v) {
7903
8224
  void *vptr = 0;
7904
- int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_System_ENUT_double_WGS84_t, SWIG_POINTER_NO_NULL);
8225
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_System_LLHT_double_WGS84_t, SWIG_POINTER_NO_NULL);
7905
8226
  _v = SWIG_CheckState(res);
7906
8227
  if (_v) {
7907
- void *vptr = 0;
7908
- int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_System_LLHT_double_WGS84_t, SWIG_POINTER_NO_NULL);
7909
- _v = SWIG_CheckState(res);
7910
- if (_v) {
7911
- return _wrap_SpaceNode_tropo_correction__SWIG_0(nargs, args, self);
7912
- }
8228
+ return _wrap_SpaceNode_tropo_correction__SWIG_0(nargs, args, self);
7913
8229
  }
7914
8230
  }
7915
8231
  }
7916
- if (argc == 3) {
8232
+ if (argc == 2) {
7917
8233
  int _v;
7918
8234
  void *vptr = 0;
7919
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_SpaceNodeT_double_t, 0);
8235
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_NO_NULL);
7920
8236
  _v = SWIG_CheckState(res);
7921
8237
  if (_v) {
7922
8238
  void *vptr = 0;
7923
8239
  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_NO_NULL);
7924
8240
  _v = SWIG_CheckState(res);
7925
8241
  if (_v) {
7926
- void *vptr = 0;
7927
- int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_NO_NULL);
7928
- _v = SWIG_CheckState(res);
7929
- if (_v) {
7930
- return _wrap_SpaceNode_tropo_correction__SWIG_1(nargs, args, self);
7931
- }
8242
+ return _wrap_SpaceNode_tropo_correction__SWIG_1(nargs, args, self);
7932
8243
  }
7933
8244
  }
7934
8245
  }
7935
8246
 
7936
8247
  fail:
7937
- Ruby_Format_OverloadedError( argc, 4, "SpaceNode.tropo_correction",
8248
+ Ruby_Format_OverloadedError( argc, 2, "SpaceNode.tropo_correction",
7938
8249
  " GPS_SpaceNode< double >::float_t SpaceNode.tropo_correction(GPS_SpaceNode< double >::enu_t const &relative_pos, GPS_SpaceNode< double >::llh_t const &usrllh)\n"
7939
8250
  " GPS_SpaceNode< double >::float_t SpaceNode.tropo_correction(GPS_SpaceNode< double >::xyz_t const &sat, GPS_SpaceNode< double >::xyz_t const &usr)\n");
7940
8251
 
@@ -14171,6 +14482,15 @@ A class method.
14171
14482
 
14172
14483
  A class method.
14173
14484
 
14485
+ */
14486
+ /*
14487
+ Document-method: GPS_PVT::GPS.L1_FREQUENCY
14488
+
14489
+ call-seq:
14490
+ L1_FREQUENCY -> int
14491
+
14492
+ A class method.
14493
+
14174
14494
  */
14175
14495
  /*
14176
14496
  Document-method: GPS_PVT::GPS.ITEMS_PREDEFINED
@@ -14464,65 +14784,11 @@ free_GPS_Measurement_Sl_double_Sg_(void *self) {
14464
14784
  static swig_class SwigClassSolverOptionsCommon;
14465
14785
 
14466
14786
  /*
14467
- Document-method: GPS_PVT::GPS.IONOSPHERIC_KLOBUCHAR
14787
+ Document-method: GPS_PVT::GPS::SolverOptionsCommon.cast_general
14468
14788
 
14469
14789
  call-seq:
14470
- IONOSPHERIC_KLOBUCHAR -> int
14471
-
14472
- A class method.
14473
-
14474
- */
14475
- /*
14476
- Document-method: GPS_PVT::GPS.IONOSPHERIC_SBAS
14477
-
14478
- call-seq:
14479
- IONOSPHERIC_SBAS -> int
14480
-
14481
- A class method.
14482
-
14483
- */
14484
- /*
14485
- Document-method: GPS_PVT::GPS.IONOSPHERIC_NTCM_GL
14486
-
14487
- call-seq:
14488
- IONOSPHERIC_NTCM_GL -> int
14489
-
14490
- A class method.
14491
-
14492
- */
14493
- /*
14494
- Document-method: GPS_PVT::GPS.IONOSPHERIC_NONE
14495
-
14496
- call-seq:
14497
- IONOSPHERIC_NONE -> int
14498
-
14499
- A class method.
14500
-
14501
- */
14502
- /*
14503
- Document-method: GPS_PVT::GPS.IONOSPHERIC_MODELS
14504
-
14505
- call-seq:
14506
- IONOSPHERIC_MODELS -> int
14507
-
14508
- A class method.
14509
-
14510
- */
14511
- /*
14512
- Document-method: GPS_PVT::GPS.IONOSPHERIC_SKIP
14513
-
14514
- call-seq:
14515
- IONOSPHERIC_SKIP -> int
14516
-
14517
- A class method.
14518
-
14519
- */
14520
- /*
14521
- Document-method: GPS_PVT::GPS::SolverOptionsCommon.cast_general
14522
-
14523
- call-seq:
14524
- cast_general -> GPS_Solver_GeneralOptions< double > *
14525
- cast_general -> GPS_Solver_GeneralOptions< double > const
14790
+ cast_general -> GPS_Solver_GeneralOptions< double > *
14791
+ cast_general -> GPS_Solver_GeneralOptions< double > const
14526
14792
 
14527
14793
  An instance method.
14528
14794
 
@@ -14632,122 +14898,6 @@ fail:
14632
14898
  }
14633
14899
 
14634
14900
 
14635
- /*
14636
- Document-method: GPS_PVT::GPS::SolverOptionsCommon.ionospheric_models
14637
-
14638
- call-seq:
14639
- ionospheric_models -> std::vector< int >
14640
-
14641
- An instance method.
14642
-
14643
- */
14644
- SWIGINTERN VALUE
14645
- _wrap_SolverOptionsCommon_ionospheric_models(int argc, VALUE *argv, VALUE self) {
14646
- GPS_SolverOptions_Common< double > *arg1 = (GPS_SolverOptions_Common< double > *) 0 ;
14647
- void *argp1 = 0 ;
14648
- int res1 = 0 ;
14649
- std::vector< int > result;
14650
- VALUE vresult = Qnil;
14651
-
14652
- if ((argc < 0) || (argc > 0)) {
14653
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14654
- }
14655
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, 0 | 0 );
14656
- if (!SWIG_IsOK(res1)) {
14657
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SolverOptions_Common< double > const *","get_ionospheric_models", 1, self ));
14658
- }
14659
- arg1 = reinterpret_cast< GPS_SolverOptions_Common< double > * >(argp1);
14660
- {
14661
- try {
14662
- result = ((GPS_SolverOptions_Common< double > const *)arg1)->get_ionospheric_models();
14663
- } catch (const native_exception &e) {
14664
- e.regenerate();
14665
- SWIG_fail;
14666
- } catch (const std::exception& e) {
14667
- SWIG_exception_fail(SWIG_RuntimeError, e.what());
14668
- }
14669
- }
14670
- {
14671
- vresult = rb_ary_new();
14672
-
14673
- for(std::vector< int >::const_iterator it((&result)->begin()), it_end((&result)->end());
14674
- it != it_end; ++it){
14675
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int (*it));
14676
- }
14677
- }
14678
- return vresult;
14679
- fail:
14680
- return Qnil;
14681
- }
14682
-
14683
-
14684
- /*
14685
- Document-method: GPS_PVT::GPS::SolverOptionsCommon.ionospheric_models=
14686
-
14687
- call-seq:
14688
- ionospheric_models=(std::vector< int > const & models) -> std::vector< int >
14689
-
14690
- An instance method.
14691
-
14692
- */
14693
- SWIGINTERN VALUE
14694
- _wrap_SolverOptionsCommon_ionospheric_modelse___(int argc, VALUE *argv, VALUE self) {
14695
- GPS_SolverOptions_Common< double > *arg1 = (GPS_SolverOptions_Common< double > *) 0 ;
14696
- std::vector< int > *arg2 = 0 ;
14697
- void *argp1 = 0 ;
14698
- int res1 = 0 ;
14699
- std::vector< int > temp2 ;
14700
- std::vector< int > result;
14701
- VALUE vresult = Qnil;
14702
-
14703
- if ((argc < 1) || (argc > 1)) {
14704
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14705
- }
14706
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, 0 | 0 );
14707
- if (!SWIG_IsOK(res1)) {
14708
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SolverOptions_Common< double > *","set_ionospheric_models", 1, self ));
14709
- }
14710
- arg1 = reinterpret_cast< GPS_SolverOptions_Common< double > * >(argp1);
14711
- {
14712
- arg2 = &temp2;
14713
-
14714
- if(RB_TYPE_P(argv[0], T_ARRAY)){
14715
- for(int i(0), i_max(RARRAY_LEN(argv[0])); i < i_max; ++i){
14716
- VALUE obj(RARRAY_AREF(argv[0], i));
14717
- int v;
14718
- if(SWIG_IsOK(SWIG_AsVal_int (obj, &v))){
14719
- temp2.push_back(v);
14720
- }else{
14721
- SWIG_exception(SWIG_TypeError, "std::vector< int > is expected");
14722
- }
14723
- }
14724
- }
14725
-
14726
- }
14727
- {
14728
- try {
14729
- result = (arg1)->set_ionospheric_models((std::vector< int > const &)*arg2);
14730
- } catch (const native_exception &e) {
14731
- e.regenerate();
14732
- SWIG_fail;
14733
- } catch (const std::exception& e) {
14734
- SWIG_exception_fail(SWIG_RuntimeError, e.what());
14735
- }
14736
- }
14737
- {
14738
- vresult = rb_ary_new();
14739
-
14740
- for(std::vector< int >::const_iterator it((&result)->begin()), it_end((&result)->end());
14741
- it != it_end; ++it){
14742
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int (*it));
14743
- }
14744
- }
14745
- return vresult;
14746
- fail:
14747
- return Qnil;
14748
- }
14749
-
14750
-
14751
14901
  /*
14752
14902
  Document-method: GPS_PVT::GPS::SolverOptionsCommon.elevation_mask=
14753
14903
 
@@ -14936,100 +15086,6 @@ fail:
14936
15086
  }
14937
15087
 
14938
15088
 
14939
- /*
14940
- Document-method: GPS_PVT::GPS::SolverOptionsCommon.f_10_7=
14941
-
14942
- call-seq:
14943
- f_10_7=(double const & v) -> double
14944
-
14945
- An instance method.
14946
-
14947
- */
14948
- SWIGINTERN VALUE
14949
- _wrap_SolverOptionsCommon_f_10_7e___(int argc, VALUE *argv, VALUE self) {
14950
- GPS_SolverOptions_Common< double > *arg1 = (GPS_SolverOptions_Common< double > *) 0 ;
14951
- double *arg2 = 0 ;
14952
- void *argp1 = 0 ;
14953
- int res1 = 0 ;
14954
- double temp2 ;
14955
- double val2 ;
14956
- int ecode2 = 0 ;
14957
- double result;
14958
- VALUE vresult = Qnil;
14959
-
14960
- if ((argc < 1) || (argc > 1)) {
14961
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14962
- }
14963
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, 0 | 0 );
14964
- if (!SWIG_IsOK(res1)) {
14965
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SolverOptions_Common< double > *","set_f_10_7", 1, self ));
14966
- }
14967
- arg1 = reinterpret_cast< GPS_SolverOptions_Common< double > * >(argp1);
14968
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
14969
- if (!SWIG_IsOK(ecode2)) {
14970
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_f_10_7", 2, argv[0] ));
14971
- }
14972
- temp2 = static_cast< double >(val2);
14973
- arg2 = &temp2;
14974
- {
14975
- try {
14976
- result = (double)GPS_SolverOptions_Common_Sl_double_Sg__set_f_10_7(arg1,(double const &)*arg2);
14977
- } catch (const native_exception &e) {
14978
- e.regenerate();
14979
- SWIG_fail;
14980
- } catch (const std::exception& e) {
14981
- SWIG_exception_fail(SWIG_RuntimeError, e.what());
14982
- }
14983
- }
14984
- vresult = SWIG_From_double(static_cast< double >(result));
14985
- return vresult;
14986
- fail:
14987
- return Qnil;
14988
- }
14989
-
14990
-
14991
- /*
14992
- Document-method: GPS_PVT::GPS::SolverOptionsCommon.f_10_7
14993
-
14994
- call-seq:
14995
- f_10_7 -> double const &
14996
-
14997
- An instance method.
14998
-
14999
- */
15000
- SWIGINTERN VALUE
15001
- _wrap_SolverOptionsCommon_f_10_7(int argc, VALUE *argv, VALUE self) {
15002
- GPS_SolverOptions_Common< double > *arg1 = (GPS_SolverOptions_Common< double > *) 0 ;
15003
- void *argp1 = 0 ;
15004
- int res1 = 0 ;
15005
- double *result = 0 ;
15006
- VALUE vresult = Qnil;
15007
-
15008
- if ((argc < 0) || (argc > 0)) {
15009
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15010
- }
15011
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, 0 | 0 );
15012
- if (!SWIG_IsOK(res1)) {
15013
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SolverOptions_Common< double > const *","get_f_10_7", 1, self ));
15014
- }
15015
- arg1 = reinterpret_cast< GPS_SolverOptions_Common< double > * >(argp1);
15016
- {
15017
- try {
15018
- result = (double *) &GPS_SolverOptions_Common_Sl_double_Sg__get_f_10_7((GPS_SolverOptions_Common< double > const *)arg1);
15019
- } catch (const native_exception &e) {
15020
- e.regenerate();
15021
- SWIG_fail;
15022
- } catch (const std::exception& e) {
15023
- SWIG_exception_fail(SWIG_RuntimeError, e.what());
15024
- }
15025
- }
15026
- vresult = SWIG_From_double(static_cast< double >(*result));
15027
- return vresult;
15028
- fail:
15029
- return Qnil;
15030
- }
15031
-
15032
-
15033
15089
  SWIGINTERN void
15034
15090
  free_GPS_SolverOptions_Common_Sl_double_Sg_(void *self) {
15035
15091
  GPS_SolverOptions_Common< double > *arg1 = (GPS_SolverOptions_Common< double > *)self;
@@ -15565,6 +15621,92 @@ fail:
15565
15621
  }
15566
15622
 
15567
15623
 
15624
+ /*
15625
+ Document-method: GPS_PVT::GPS::Solver.correction
15626
+
15627
+ call-seq:
15628
+ correction -> VALUE
15629
+
15630
+ An instance method.
15631
+
15632
+ */
15633
+ SWIGINTERN VALUE
15634
+ _wrap_Solver_correction(int argc, VALUE *argv, VALUE self) {
15635
+ GPS_Solver< double > *arg1 = (GPS_Solver< double > *) 0 ;
15636
+ void *argp1 = 0 ;
15637
+ int res1 = 0 ;
15638
+ VALUE result;
15639
+ VALUE vresult = Qnil;
15640
+
15641
+ if ((argc < 0) || (argc > 0)) {
15642
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15643
+ }
15644
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SolverT_double_t, 0 | 0 );
15645
+ if (!SWIG_IsOK(res1)) {
15646
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Solver< double > const *","get_correction", 1, self ));
15647
+ }
15648
+ arg1 = reinterpret_cast< GPS_Solver< double > * >(argp1);
15649
+ {
15650
+ try {
15651
+ result = (VALUE)GPS_Solver_Sl_double_Sg__get_correction((GPS_Solver< double > const *)arg1);
15652
+ } catch (const native_exception &e) {
15653
+ e.regenerate();
15654
+ SWIG_fail;
15655
+ } catch (const std::exception& e) {
15656
+ SWIG_exception_fail(SWIG_RuntimeError, e.what());
15657
+ }
15658
+ }
15659
+ vresult = result;
15660
+ return vresult;
15661
+ fail:
15662
+ return Qnil;
15663
+ }
15664
+
15665
+
15666
+ /*
15667
+ Document-method: GPS_PVT::GPS::Solver.correction=
15668
+
15669
+ call-seq:
15670
+ correction=(VALUE hash) -> VALUE
15671
+
15672
+ An instance method.
15673
+
15674
+ */
15675
+ SWIGINTERN VALUE
15676
+ _wrap_Solver_correctione___(int argc, VALUE *argv, VALUE self) {
15677
+ GPS_Solver< double > *arg1 = (GPS_Solver< double > *) 0 ;
15678
+ VALUE arg2 = (VALUE) 0 ;
15679
+ void *argp1 = 0 ;
15680
+ int res1 = 0 ;
15681
+ VALUE result;
15682
+ VALUE vresult = Qnil;
15683
+
15684
+ if ((argc < 1) || (argc > 1)) {
15685
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
15686
+ }
15687
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SolverT_double_t, 0 | 0 );
15688
+ if (!SWIG_IsOK(res1)) {
15689
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Solver< double > *","set_correction", 1, self ));
15690
+ }
15691
+ arg1 = reinterpret_cast< GPS_Solver< double > * >(argp1);
15692
+ arg2 = argv[0];
15693
+ {
15694
+ try {
15695
+ result = (VALUE)GPS_Solver_Sl_double_Sg__set_correction(arg1,arg2);
15696
+ } catch (const native_exception &e) {
15697
+ e.regenerate();
15698
+ SWIG_fail;
15699
+ } catch (const std::exception& e) {
15700
+ SWIG_exception_fail(SWIG_RuntimeError, e.what());
15701
+ }
15702
+ }
15703
+ vresult = result;
15704
+ return vresult;
15705
+ fail:
15706
+ return Qnil;
15707
+ }
15708
+
15709
+
15568
15710
  SWIGINTERN void
15569
15711
  free_GPS_Solver_Sl_double_Sg_(void *self) {
15570
15712
  GPS_Solver< double > *arg1 = (GPS_Solver< double > *)self;
@@ -17678,60 +17820,52 @@ fail:
17678
17820
  call-seq:
17679
17821
  tropo_correction(SBAS_SpaceNode< double >::float_t const & year_utc, ENU relative_pos, LLH usrllh) -> SBAS_SpaceNode< double >::float_t
17680
17822
 
17681
- An instance method.
17823
+ A class method.
17682
17824
 
17683
17825
  */
17684
17826
  SWIGINTERN VALUE
17685
17827
  _wrap_SpaceNode_SBAS_tropo_correction(int argc, VALUE *argv, VALUE self) {
17686
- SBAS_SpaceNode< double > *arg1 = (SBAS_SpaceNode< double > *) 0 ;
17687
- SBAS_SpaceNode< double >::float_t *arg2 = 0 ;
17688
- SBAS_SpaceNode< double >::enu_t *arg3 = 0 ;
17689
- SBAS_SpaceNode< double >::llh_t *arg4 = 0 ;
17690
- void *argp1 = 0 ;
17691
- int res1 = 0 ;
17692
- SBAS_SpaceNode< double >::float_t temp2 ;
17693
- double val2 ;
17694
- int ecode2 = 0 ;
17828
+ SBAS_SpaceNode< double >::float_t *arg1 = 0 ;
17829
+ SBAS_SpaceNode< double >::enu_t *arg2 = 0 ;
17830
+ SBAS_SpaceNode< double >::llh_t *arg3 = 0 ;
17831
+ SBAS_SpaceNode< double >::float_t temp1 ;
17832
+ double val1 ;
17833
+ int ecode1 = 0 ;
17834
+ void *argp2 ;
17835
+ int res2 = 0 ;
17695
17836
  void *argp3 ;
17696
17837
  int res3 = 0 ;
17697
- void *argp4 ;
17698
- int res4 = 0 ;
17699
17838
  SBAS_SpaceNode< double >::float_t result;
17700
17839
  VALUE vresult = Qnil;
17701
17840
 
17702
17841
  if ((argc < 3) || (argc > 3)) {
17703
17842
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
17704
17843
  }
17705
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SBAS_SpaceNodeT_double_t, 0 | 0 );
17706
- if (!SWIG_IsOK(res1)) {
17707
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double > const *","tropo_correction", 1, self ));
17708
- }
17709
- arg1 = reinterpret_cast< SBAS_SpaceNode< double > * >(argp1);
17710
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
17711
- if (!SWIG_IsOK(ecode2)) {
17712
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double >::float_t","tropo_correction", 2, argv[0] ));
17844
+ ecode1 = SWIG_AsVal_double(argv[0], &val1);
17845
+ if (!SWIG_IsOK(ecode1)) {
17846
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double >::float_t","SBAS_SpaceNode<(double)>::tropo_correction", 1, argv[0] ));
17713
17847
  }
17714
- temp2 = static_cast< SBAS_SpaceNode< double >::float_t >(val2);
17715
- arg2 = &temp2;
17716
- res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_System_ENUT_double_WGS84_t, 0 );
17717
- if (!SWIG_IsOK(res3)) {
17718
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double >::enu_t const &","tropo_correction", 3, argv[1] ));
17848
+ temp1 = static_cast< SBAS_SpaceNode< double >::float_t >(val1);
17849
+ arg1 = &temp1;
17850
+ res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_System_ENUT_double_WGS84_t, 0 );
17851
+ if (!SWIG_IsOK(res2)) {
17852
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double >::enu_t const &","SBAS_SpaceNode<(double)>::tropo_correction", 2, argv[1] ));
17719
17853
  }
17720
- if (!argp3) {
17721
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "SBAS_SpaceNode< double >::enu_t const &","tropo_correction", 3, argv[1]));
17854
+ if (!argp2) {
17855
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "SBAS_SpaceNode< double >::enu_t const &","SBAS_SpaceNode<(double)>::tropo_correction", 2, argv[1]));
17722
17856
  }
17723
- arg3 = reinterpret_cast< SBAS_SpaceNode< double >::enu_t * >(argp3);
17724
- res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_System_LLHT_double_WGS84_t, 0 );
17725
- if (!SWIG_IsOK(res4)) {
17726
- SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double >::llh_t const &","tropo_correction", 4, argv[2] ));
17857
+ arg2 = reinterpret_cast< SBAS_SpaceNode< double >::enu_t * >(argp2);
17858
+ res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_System_LLHT_double_WGS84_t, 0 );
17859
+ if (!SWIG_IsOK(res3)) {
17860
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double >::llh_t const &","SBAS_SpaceNode<(double)>::tropo_correction", 3, argv[2] ));
17727
17861
  }
17728
- if (!argp4) {
17729
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "SBAS_SpaceNode< double >::llh_t const &","tropo_correction", 4, argv[2]));
17862
+ if (!argp3) {
17863
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "SBAS_SpaceNode< double >::llh_t const &","SBAS_SpaceNode<(double)>::tropo_correction", 3, argv[2]));
17730
17864
  }
17731
- arg4 = reinterpret_cast< SBAS_SpaceNode< double >::llh_t * >(argp4);
17865
+ arg3 = reinterpret_cast< SBAS_SpaceNode< double >::llh_t * >(argp3);
17732
17866
  {
17733
17867
  try {
17734
- result = (SBAS_SpaceNode< double >::float_t)((SBAS_SpaceNode< double > const *)arg1)->tropo_correction((SBAS_SpaceNode< double >::float_t const &)*arg2,(SBAS_SpaceNode< double >::enu_t const &)*arg3,(SBAS_SpaceNode< double >::llh_t const &)*arg4);
17868
+ result = (SBAS_SpaceNode< double >::float_t)SBAS_SpaceNode< double >::SWIGTEMPLATEDISAMBIGUATOR tropo_correction((double const &)*arg1,(System_ENU< double,WGS84 > const &)*arg2,(System_LLH< double,WGS84 > const &)*arg3);
17735
17869
  } catch (const native_exception &e) {
17736
17870
  e.regenerate();
17737
17871
  SWIG_fail;
@@ -18914,12 +19048,12 @@ static swig_type_info _swigt__p_int_t = {"_p_int_t", "int_t *", 0, 0, (void*)0,
18914
19048
  static swig_type_info _swigt__p_llh_t = {"_p_llh_t", "llh_t *", 0, 0, (void*)0, 0};
18915
19049
  static swig_type_info _swigt__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t = {"_p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t", "GPS_User_PVT< double >::base_t::detection_t **|GPS_Solver_RAIM_LSR< double,GPS_Solver_Base_Debug< double,GPS_Solver_Base< double > > >::user_pvt_t::detection_t **", 0, 0, (void*)0, 0};
18916
19050
  static swig_type_info _swigt__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t = {"_p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t", "GPS_User_PVT< double >::base_t::exclusion_t **|GPS_Solver_RAIM_LSR< double,GPS_Solver_Base_Debug< double,GPS_Solver_Base< double > > >::user_pvt_t::exclusion_t **", 0, 0, (void*)0, 0};
19051
+ static swig_type_info _swigt__p_range_correction_list_t = {"_p_range_correction_list_t", "range_correction_list_t *", 0, 0, (void*)0, 0};
18917
19052
  static swig_type_info _swigt__p_s16_t = {"_p_s16_t", "s16_t *", 0, 0, (void*)0, 0};
18918
19053
  static swig_type_info _swigt__p_s32_t = {"_p_s32_t", "s32_t *", 0, 0, (void*)0, 0};
18919
19054
  static swig_type_info _swigt__p_s8_t = {"_p_s8_t", "s8_t *", 0, 0, (void*)0, 0};
18920
19055
  static swig_type_info _swigt__p_satellites_t = {"_p_satellites_t", "satellites_t *", 0, 0, (void*)0, 0};
18921
19056
  static swig_type_info _swigt__p_self_t = {"_p_self_t", "self_t *", 0, 0, (void*)0, 0};
18922
- static swig_type_info _swigt__p_std__vectorT_int_t = {"_p_std__vectorT_int_t", "std::vector< int > *", 0, 0, (void*)0, 0};
18923
19057
  static swig_type_info _swigt__p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t = {"_p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t", "SBAS_SpaceNode< double >::available_satellites_t *|std::vector< std::pair< int,SBAS_SpaceNode< double >::Satellite const * > > *", 0, 0, (void*)0, 0};
18924
19058
  static swig_type_info _swigt__p_swig__GC_VALUE = {"_p_swig__GC_VALUE", "swig::GC_VALUE *", 0, 0, (void*)0, 0};
18925
19059
  static swig_type_info _swigt__p_u16_t = {"_p_u16_t", "u16_t *", 0, 0, (void*)0, 0};
@@ -18971,12 +19105,12 @@ static swig_type_info *swig_type_initial[] = {
18971
19105
  &_swigt__p_llh_t,
18972
19106
  &_swigt__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t,
18973
19107
  &_swigt__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t,
19108
+ &_swigt__p_range_correction_list_t,
18974
19109
  &_swigt__p_s16_t,
18975
19110
  &_swigt__p_s32_t,
18976
19111
  &_swigt__p_s8_t,
18977
19112
  &_swigt__p_satellites_t,
18978
19113
  &_swigt__p_self_t,
18979
- &_swigt__p_std__vectorT_int_t,
18980
19114
  &_swigt__p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t,
18981
19115
  &_swigt__p_swig__GC_VALUE,
18982
19116
  &_swigt__p_u16_t,
@@ -19028,12 +19162,12 @@ static swig_cast_info _swigc__p_int_t[] = { {&_swigt__p_int_t, 0, 0, 0},{0, 0,
19028
19162
  static swig_cast_info _swigc__p_llh_t[] = { {&_swigt__p_llh_t, 0, 0, 0},{0, 0, 0, 0}};
19029
19163
  static swig_cast_info _swigc__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t[] = { {&_swigt__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t, 0, 0, 0},{0, 0, 0, 0}};
19030
19164
  static swig_cast_info _swigc__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t[] = { {&_swigt__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t, 0, 0, 0},{0, 0, 0, 0}};
19165
+ static swig_cast_info _swigc__p_range_correction_list_t[] = { {&_swigt__p_range_correction_list_t, 0, 0, 0},{0, 0, 0, 0}};
19031
19166
  static swig_cast_info _swigc__p_s16_t[] = { {&_swigt__p_s16_t, 0, 0, 0},{0, 0, 0, 0}};
19032
19167
  static swig_cast_info _swigc__p_s32_t[] = { {&_swigt__p_s32_t, 0, 0, 0},{0, 0, 0, 0}};
19033
19168
  static swig_cast_info _swigc__p_s8_t[] = { {&_swigt__p_s8_t, 0, 0, 0},{0, 0, 0, 0}};
19034
19169
  static swig_cast_info _swigc__p_satellites_t[] = { {&_swigt__p_satellites_t, 0, 0, 0},{0, 0, 0, 0}};
19035
19170
  static swig_cast_info _swigc__p_self_t[] = { {&_swigt__p_self_t, 0, 0, 0},{0, 0, 0, 0}};
19036
- static swig_cast_info _swigc__p_std__vectorT_int_t[] = { {&_swigt__p_std__vectorT_int_t, 0, 0, 0},{0, 0, 0, 0}};
19037
19171
  static swig_cast_info _swigc__p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t[] = { {&_swigt__p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
19038
19172
  static swig_cast_info _swigc__p_swig__GC_VALUE[] = { {&_swigt__p_swig__GC_VALUE, 0, 0, 0},{0, 0, 0, 0}};
19039
19173
  static swig_cast_info _swigc__p_u16_t[] = { {&_swigt__p_u16_t, 0, 0, 0},{0, 0, 0, 0}};
@@ -19085,12 +19219,12 @@ static swig_cast_info *swig_cast_initial[] = {
19085
19219
  _swigc__p_llh_t,
19086
19220
  _swigc__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t,
19087
19221
  _swigc__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t,
19222
+ _swigc__p_range_correction_list_t,
19088
19223
  _swigc__p_s16_t,
19089
19224
  _swigc__p_s32_t,
19090
19225
  _swigc__p_s8_t,
19091
19226
  _swigc__p_satellites_t,
19092
19227
  _swigc__p_self_t,
19093
- _swigc__p_std__vectorT_int_t,
19094
19228
  _swigc__p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t,
19095
19229
  _swigc__p_swig__GC_VALUE,
19096
19230
  _swigc__p_u16_t,
@@ -19397,6 +19531,7 @@ SWIGEXPORT void Init_GPS(void) {
19397
19531
  rb_define_singleton_method(SwigClassTime.klass, "leap_second_events", VALUEFUNC(_wrap_Time_leap_second_events_get), 0);
19398
19532
  rb_define_singleton_method(SwigClassTime.klass, "guess_leap_seconds", VALUEFUNC(_wrap_Time_guess_leap_seconds), -1);
19399
19533
  rb_define_method(SwigClassTime.klass, "to_a", VALUEFUNC(_wrap_Time_to_a), -1);
19534
+ rb_define_method(SwigClassTime.klass, "<=>", VALUEFUNC(_wrap_Time___cmp__), -1);
19400
19535
  SwigClassTime.mark = 0;
19401
19536
  SwigClassTime.destroy = (void (*)(void *)) free_GPS_Time_Sl_double_Sg_;
19402
19537
  SwigClassTime.trackObjects = 0;
@@ -19412,6 +19547,7 @@ SWIGEXPORT void Init_GPS(void) {
19412
19547
  rb_define_singleton_method(SwigClassSpaceNode.klass, "L2_Frequency", VALUEFUNC(_wrap_SpaceNode_L2_Frequency_get), 0);
19413
19548
  rb_define_singleton_method(SwigClassSpaceNode.klass, "L2_WaveLength", VALUEFUNC(_wrap_SpaceNode_L2_WaveLength), -1);
19414
19549
  rb_define_singleton_method(SwigClassSpaceNode.klass, "gamma_L1_L2", VALUEFUNC(_wrap_SpaceNode_gamma_L1_L2_get), 0);
19550
+ rb_define_singleton_method(SwigClassSpaceNode.klass, "gamma_per_L1", VALUEFUNC(_wrap_SpaceNode_gamma_per_L1), -1);
19415
19551
  rb_define_method(SwigClassSpaceNode.klass, "iono_utc", VALUEFUNC(_wrap_SpaceNode_iono_utc), -1);
19416
19552
  rb_define_method(SwigClassSpaceNode.klass, "is_valid_iono", VALUEFUNC(_wrap_SpaceNode_is_valid_iono), -1);
19417
19553
  rb_define_method(SwigClassSpaceNode.klass, "is_valid_utc", VALUEFUNC(_wrap_SpaceNode_is_valid_utc), -1);
@@ -19425,7 +19561,7 @@ SWIGEXPORT void Init_GPS(void) {
19425
19561
  rb_define_singleton_method(SwigClassSpaceNode.klass, "tec2delay", VALUEFUNC(_wrap_SpaceNode_tec2delay), -1);
19426
19562
  rb_define_method(SwigClassSpaceNode.klass, "iono_correction", VALUEFUNC(_wrap_SpaceNode_iono_correction), -1);
19427
19563
  rb_define_singleton_method(SwigClassSpaceNode.klass, "tropo_correction_zenith_hydrostatic_Saastamoinen", VALUEFUNC(_wrap_SpaceNode_tropo_correction_zenith_hydrostatic_Saastamoinen), -1);
19428
- rb_define_method(SwigClassSpaceNode.klass, "tropo_correction", VALUEFUNC(_wrap_SpaceNode_tropo_correction), -1);
19564
+ rb_define_singleton_method(SwigClassSpaceNode.klass, "tropo_correction", VALUEFUNC(_wrap_SpaceNode_tropo_correction), -1);
19429
19565
  rb_define_method(SwigClassSpaceNode.klass, "register_ephemeris", VALUEFUNC(_wrap_SpaceNode_register_ephemeris), -1);
19430
19566
  rb_define_method(SwigClassSpaceNode.klass, "ephemeris", VALUEFUNC(_wrap_SpaceNode_ephemeris), -1);
19431
19567
  rb_define_method(SwigClassSpaceNode.klass, "read", VALUEFUNC(_wrap_SpaceNode_read), -1);
@@ -19594,6 +19730,7 @@ SWIGEXPORT void Init_GPS(void) {
19594
19730
  rb_define_const(SwigClassMeasurement.klass, "L1_RANGE_RATE_SIGMA", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L1_RANGE_RATE_SIGMA)));
19595
19731
  rb_define_const(SwigClassMeasurement.klass, "L1_SIGNAL_STRENGTH_dBHz", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L1_SIGNAL_STRENGTH_dBHz)));
19596
19732
  rb_define_const(SwigClassMeasurement.klass, "L1_LOCK_SEC", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L1_LOCK_SEC)));
19733
+ rb_define_const(SwigClassMeasurement.klass, "L1_FREQUENCY", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L1_FREQUENCY)));
19597
19734
  rb_define_const(SwigClassMeasurement.klass, "ITEMS_PREDEFINED", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::ITEMS_PREDEFINED)));
19598
19735
  rb_define_method(SwigClassMeasurement.klass, "add", VALUEFUNC(_wrap_Measurement_add), -1);
19599
19736
  rb_define_method(SwigClassMeasurement.klass, "each", VALUEFUNC(_wrap_Measurement_each), -1);
@@ -19605,21 +19742,11 @@ SWIGEXPORT void Init_GPS(void) {
19605
19742
  SwigClassSolverOptionsCommon.klass = rb_define_class_under(mGPS, "SolverOptionsCommon", rb_cObject);
19606
19743
  SWIG_TypeClientData(SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, (void *) &SwigClassSolverOptionsCommon);
19607
19744
  rb_undef_alloc_func(SwigClassSolverOptionsCommon.klass);
19608
- rb_define_const(SwigClassSolverOptionsCommon.klass, "IONOSPHERIC_KLOBUCHAR", SWIG_From_int(static_cast< int >(GPS_SolverOptions_Common< double >::IONOSPHERIC_KLOBUCHAR)));
19609
- rb_define_const(SwigClassSolverOptionsCommon.klass, "IONOSPHERIC_SBAS", SWIG_From_int(static_cast< int >(GPS_SolverOptions_Common< double >::IONOSPHERIC_SBAS)));
19610
- rb_define_const(SwigClassSolverOptionsCommon.klass, "IONOSPHERIC_NTCM_GL", SWIG_From_int(static_cast< int >(GPS_SolverOptions_Common< double >::IONOSPHERIC_NTCM_GL)));
19611
- rb_define_const(SwigClassSolverOptionsCommon.klass, "IONOSPHERIC_NONE", SWIG_From_int(static_cast< int >(GPS_SolverOptions_Common< double >::IONOSPHERIC_NONE)));
19612
- rb_define_const(SwigClassSolverOptionsCommon.klass, "IONOSPHERIC_MODELS", SWIG_From_int(static_cast< int >(GPS_SolverOptions_Common< double >::IONOSPHERIC_MODELS)));
19613
- rb_define_const(SwigClassSolverOptionsCommon.klass, "IONOSPHERIC_SKIP", SWIG_From_int(static_cast< int >(GPS_SolverOptions_Common< double >::IONOSPHERIC_SKIP)));
19614
19745
  rb_define_method(SwigClassSolverOptionsCommon.klass, "cast_general", VALUEFUNC(_wrap_SolverOptionsCommon_cast_general), -1);
19615
- rb_define_method(SwigClassSolverOptionsCommon.klass, "ionospheric_models", VALUEFUNC(_wrap_SolverOptionsCommon_ionospheric_models), -1);
19616
- rb_define_method(SwigClassSolverOptionsCommon.klass, "ionospheric_models=", VALUEFUNC(_wrap_SolverOptionsCommon_ionospheric_modelse___), -1);
19617
19746
  rb_define_method(SwigClassSolverOptionsCommon.klass, "elevation_mask=", VALUEFUNC(_wrap_SolverOptionsCommon_elevation_maske___), -1);
19618
19747
  rb_define_method(SwigClassSolverOptionsCommon.klass, "elevation_mask", VALUEFUNC(_wrap_SolverOptionsCommon_elevation_mask), -1);
19619
19748
  rb_define_method(SwigClassSolverOptionsCommon.klass, "residual_mask=", VALUEFUNC(_wrap_SolverOptionsCommon_residual_maske___), -1);
19620
19749
  rb_define_method(SwigClassSolverOptionsCommon.klass, "residual_mask", VALUEFUNC(_wrap_SolverOptionsCommon_residual_mask), -1);
19621
- rb_define_method(SwigClassSolverOptionsCommon.klass, "f_10_7=", VALUEFUNC(_wrap_SolverOptionsCommon_f_10_7e___), -1);
19622
- rb_define_method(SwigClassSolverOptionsCommon.klass, "f_10_7", VALUEFUNC(_wrap_SolverOptionsCommon_f_10_7), -1);
19623
19750
  SwigClassSolverOptionsCommon.mark = 0;
19624
19751
  SwigClassSolverOptionsCommon.destroy = (void (*)(void *)) free_GPS_SolverOptions_Common_Sl_double_Sg_;
19625
19752
  SwigClassSolverOptionsCommon.trackObjects = 0;
@@ -19645,6 +19772,8 @@ SWIGEXPORT void Init_GPS(void) {
19645
19772
  rb_define_method(SwigClassSolver.klass, "sbas_space_node", VALUEFUNC(_wrap_Solver_sbas_space_node), -1);
19646
19773
  rb_define_method(SwigClassSolver.klass, "sbas_options", VALUEFUNC(_wrap_Solver_sbas_options), -1);
19647
19774
  rb_define_method(SwigClassSolver.klass, "solve", VALUEFUNC(_wrap_Solver_solve), -1);
19775
+ rb_define_method(SwigClassSolver.klass, "correction", VALUEFUNC(_wrap_Solver_correction), -1);
19776
+ rb_define_method(SwigClassSolver.klass, "correction=", VALUEFUNC(_wrap_Solver_correctione___), -1);
19648
19777
  SwigClassSolver.mark = (void (*)(void *)) GPS_Solver<double>::mark;
19649
19778
  SwigClassSolver.destroy = (void (*)(void *)) free_GPS_Solver_Sl_double_Sg_;
19650
19779
  SwigClassSolver.trackObjects = 0;
@@ -19714,7 +19843,7 @@ SWIGEXPORT void Init_GPS(void) {
19714
19843
  rb_define_const(SwigClassSpaceNode_SBAS.klass, "NULL_MESSAGES", SWIG_From_int(static_cast< int >(SBAS_SpaceNode< double >::NULL_MESSAGES)));
19715
19844
  rb_define_const(SwigClassSpaceNode_SBAS.klass, "UNSUPPORTED_MESSAGE", SWIG_From_int(static_cast< int >(SBAS_SpaceNode< double >::UNSUPPORTED_MESSAGE)));
19716
19845
  rb_define_singleton_method(SwigClassSpaceNode_SBAS.klass, "sagnac_correction", VALUEFUNC(_wrap_SpaceNode_SBAS_sagnac_correction), -1);
19717
- rb_define_method(SwigClassSpaceNode_SBAS.klass, "tropo_correction", VALUEFUNC(_wrap_SpaceNode_SBAS_tropo_correction), -1);
19846
+ rb_define_singleton_method(SwigClassSpaceNode_SBAS.klass, "tropo_correction", VALUEFUNC(_wrap_SpaceNode_SBAS_tropo_correction), -1);
19718
19847
  rb_define_method(SwigClassSpaceNode_SBAS.klass, "has_satellite", VALUEFUNC(_wrap_SpaceNode_SBAS_has_satellite), -1);
19719
19848
  rb_define_method(SwigClassSpaceNode_SBAS.klass, "update_all_ephemeris", VALUEFUNC(_wrap_SpaceNode_SBAS_update_all_ephemeris), -1);
19720
19849
  rb_define_method(SwigClassSpaceNode_SBAS.klass, "available_satellites", VALUEFUNC(_wrap_SpaceNode_SBAS_available_satellites), -1);