Class: GPS_PVT::GPS::SpaceNode

Inherits:
Object
  • Object
show all
Defined in:
ext/gps_pvt/GPS/GPS_wrap.cxx,
ext/gps_pvt/GPS/GPS_wrap.cxx

Overview

Proxy of C++ GPS_PVT::GPS::SpaceNode class

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object

call-seq:

SpaceNode.new

Class constructor.



7816
7817
7818
7819
7820
7821
7822
7823
7824
7825
7826
7827
7828
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7816

SWIGINTERN VALUE
_wrap_new_SpaceNode(int argc, VALUE *argv, VALUE self) {
  GPS_SpaceNode< double > *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (GPS_SpaceNode< double > *)new GPS_SpaceNode< double >();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}

Class Method Details

.gamma_L1_L2 ⇒ Object

call-seq:

SpaceNode_gamma_L1_L2 -> GPS_SpaceNode< double >::float_t const

Get value of attribute.



7748
7749
7750
7751
7752
7753
7754
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7748

SWIGINTERN VALUE
_wrap_SpaceNode_gamma_L1_L2_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_double(static_cast< double >(GPS_SpaceNode< double >::gamma_L1_L2));
  return _val;
}

.gamma_per_L1(*args) ⇒ Object

call-seq:

gamma_per_L1(GPS_SpaceNode< double >::float_t const & freq) -> GPS_SpaceNode< double >::float_t const

A class method.



7766
7767
7768
7769
7770
7771
7772
7773
7774
7775
7776
7777
7778
7779
7780
7781
7782
7783
7784
7785
7786
7787
7788
7789
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7766

SWIGINTERN VALUE
_wrap_SpaceNode_gamma_per_L1(int argc, VALUE *argv, VALUE self) {
  GPS_SpaceNode< double >::float_t *arg1 = 0 ;
  GPS_SpaceNode< double >::float_t temp1 ;
  double val1 ;
  int ecode1 = 0 ;
  GPS_SpaceNode< double >::float_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::float_t","GPS_SpaceNode<(double)>::gamma_per_L1", 1, argv[0] ));
  } 
  temp1 = static_cast< GPS_SpaceNode< double >::float_t >(val1);
  arg1 = &temp1;
  result = (GPS_SpaceNode< double >::float_t)GPS_SpaceNode< double >::SWIGTEMPLATEDISAMBIGUATOR gamma_per_L1((double const &)*arg1);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

.L1_Frequency ⇒ Object

call-seq:

SpaceNode_L1_Frequency -> GPS_SpaceNode< double >::float_t const

Get value of attribute.



7617
7618
7619
7620
7621
7622
7623
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7617

SWIGINTERN VALUE
_wrap_SpaceNode_L1_Frequency_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_double(static_cast< double >(GPS_SpaceNode< double >::L1_Frequency));
  return _val;
}

.L1_WaveLength(*args) ⇒ Object

call-seq:

L1_WaveLength -> GPS_SpaceNode< double >::float_t const &

A class method.



7635
7636
7637
7638
7639
7640
7641
7642
7643
7644
7645
7646
7647
7648
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7635

SWIGINTERN VALUE
_wrap_SpaceNode_L1_WaveLength(int argc, VALUE *argv, VALUE self) {
  GPS_SpaceNode< double >::float_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (GPS_SpaceNode< double >::float_t *) &GPS_SpaceNode< double >::SWIGTEMPLATEDISAMBIGUATOR L1_WaveLength();
  vresult = SWIG_From_double(static_cast< double >(*result));
  return vresult;
fail:
  return Qnil;
}

.L2_Frequency ⇒ Object

call-seq:

SpaceNode_L2_Frequency -> GPS_SpaceNode< double >::float_t const

Get value of attribute.



7696
7697
7698
7699
7700
7701
7702
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7696

SWIGINTERN VALUE
_wrap_SpaceNode_L2_Frequency_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_double(static_cast< double >(GPS_SpaceNode< double >::L2_Frequency));
  return _val;
}

.L2_WaveLength(*args) ⇒ Object

call-seq:

L2_WaveLength -> GPS_SpaceNode< double >::float_t const &

A class method.



7714
7715
7716
7717
7718
7719
7720
7721
7722
7723
7724
7725
7726
7727
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7714

SWIGINTERN VALUE
_wrap_SpaceNode_L2_WaveLength(int argc, VALUE *argv, VALUE self) {
  GPS_SpaceNode< double >::float_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (GPS_SpaceNode< double >::float_t *) &GPS_SpaceNode< double >::SWIGTEMPLATEDISAMBIGUATOR L2_WaveLength();
  vresult = SWIG_From_double(static_cast< double >(*result));
  return vresult;
fail:
  return Qnil;
}

.light_speed ⇒ Object

call-seq:

SpaceNode_light_speed -> GPS_SpaceNode< double >::float_t const

Get value of attribute.



7590
7591
7592
7593
7594
7595
7596
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7590

SWIGINTERN VALUE
_wrap_SpaceNode_light_speed_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_double(static_cast< double >(GPS_SpaceNode< double >::light_speed));
  return _val;
}

.pierce_point(*args, self) ⇒ Object

call-seq:

pierce_point(ENU relative_pos, LLH usrllh, GPS_SpaceNode< double >::float_t const & height_over_ellipsoid=350E3) -> GPS_SpaceNode< double >::pierce_point_res_t
pierce_point(ENU relative_pos, LLH usrllh) -> GPS_SpaceNode< double >::pierce_point_res_t

A class method.



8547
8548
8549
8550
8551
8552
8553
8554
8555
8556
8557
8558
8559
8560
8561
8562
8563
8564
8565
8566
8567
8568
8569
8570
8571
8572
8573
8574
8575
8576
8577
8578
8579
8580
8581
8582
8583
8584
8585
8586
8587
8588
8589
8590
8591
8592
8593
8594
8595
8596
8597
8598
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8547

SWIGINTERN VALUE _wrap_SpaceNode_pierce_point(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_System_ENUT_double_WGS84_t, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_System_LLHT_double_WGS84_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SpaceNode_pierce_point__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_System_ENUT_double_WGS84_t, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_System_LLHT_double_WGS84_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SpaceNode_pierce_point__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SpaceNode.pierce_point", 
    "    GPS_SpaceNode< double >::pierce_point_res_t SpaceNode.pierce_point(GPS_SpaceNode< double >::enu_t const &relative_pos, GPS_SpaceNode< double >::llh_t const &usrllh, GPS_SpaceNode< double >::float_t const &height_over_ellipsoid)\n"
    "    GPS_SpaceNode< double >::pierce_point_res_t SpaceNode.pierce_point(GPS_SpaceNode< double >::enu_t const &relative_pos, GPS_SpaceNode< double >::llh_t const &usrllh)\n");
  
  return Qnil;
}

.SC2RAD ⇒ Object

call-seq:

SpaceNode_SC2RAD -> GPS_SpaceNode< double >::float_t const

Get value of attribute.



7669
7670
7671
7672
7673
7674
7675
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7669

SWIGINTERN VALUE
_wrap_SpaceNode_SC2RAD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_double(static_cast< double >(GPS_SpaceNode< double >::SC2RAD));
  return _val;
}

.slant_factor(*args, self) ⇒ Object

call-seq:

slant_factor(ENU relative_pos, GPS_SpaceNode< double >::float_t const & height_over_ellipsoid=350E3) -> GPS_SpaceNode< double >::float_t
slant_factor(ENU relative_pos) -> GPS_SpaceNode< double >::float_t

A class method.



8675
8676
8677
8678
8679
8680
8681
8682
8683
8684
8685
8686
8687
8688
8689
8690
8691
8692
8693
8694
8695
8696
8697
8698
8699
8700
8701
8702
8703
8704
8705
8706
8707
8708
8709
8710
8711
8712
8713
8714
8715
8716
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8675

SWIGINTERN VALUE _wrap_SpaceNode_slant_factor(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_System_ENUT_double_WGS84_t, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SpaceNode_slant_factor__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_System_ENUT_double_WGS84_t, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SpaceNode_slant_factor__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "SpaceNode.slant_factor", 
    "    GPS_SpaceNode< double >::float_t SpaceNode.slant_factor(GPS_SpaceNode< double >::enu_t const &relative_pos, GPS_SpaceNode< double >::float_t const &height_over_ellipsoid)\n"
    "    GPS_SpaceNode< double >::float_t SpaceNode.slant_factor(GPS_SpaceNode< double >::enu_t const &relative_pos)\n");
  
  return Qnil;
}

.tec2delay(*args, self) ⇒ Object

call-seq:

tec2delay(GPS_SpaceNode< double >::float_t const & tec, GPS_SpaceNode< double >::float_t const & freq=GPS_SpaceNode< double >::L1_Frequency) -> GPS_SpaceNode< double >::float_t
tec2delay(GPS_SpaceNode< double >::float_t const & tec) -> GPS_SpaceNode< double >::float_t

A class method.



8791
8792
8793
8794
8795
8796
8797
8798
8799
8800
8801
8802
8803
8804
8805
8806
8807
8808
8809
8810
8811
8812
8813
8814
8815
8816
8817
8818
8819
8820
8821
8822
8823
8824
8825
8826
8827
8828
8829
8830
8831
8832
8833
8834
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8791

SWIGINTERN VALUE _wrap_SpaceNode_tec2delay(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_SpaceNode_tec2delay__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SpaceNode_tec2delay__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "SpaceNode.tec2delay", 
    "    GPS_SpaceNode< double >::float_t SpaceNode.tec2delay(GPS_SpaceNode< double >::float_t const &tec, GPS_SpaceNode< double >::float_t const &freq)\n"
    "    GPS_SpaceNode< double >::float_t SpaceNode.tec2delay(GPS_SpaceNode< double >::float_t const &tec)\n");
  
  return Qnil;
}

.tropo_correction(*args, self) ⇒ Object

call-seq:

tropo_correction(ENU relative_pos, LLH usrllh) -> GPS_SpaceNode< double >::float_t
tropo_correction(XYZ sat, XYZ usr) -> GPS_SpaceNode< double >::float_t

A class method.



9182
9183
9184
9185
9186
9187
9188
9189
9190
9191
9192
9193
9194
9195
9196
9197
9198
9199
9200
9201
9202
9203
9204
9205
9206
9207
9208
9209
9210
9211
9212
9213
9214
9215
9216
9217
9218
9219
9220
9221
9222
9223
9224
9225
9226
9227
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9182

SWIGINTERN VALUE _wrap_SpaceNode_tropo_correction(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_System_ENUT_double_WGS84_t, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_System_LLHT_double_WGS84_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SpaceNode_tropo_correction__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SpaceNode_tropo_correction__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "SpaceNode.tropo_correction", 
    "    GPS_SpaceNode< double >::float_t SpaceNode.tropo_correction(GPS_SpaceNode< double >::enu_t const &relative_pos, GPS_SpaceNode< double >::llh_t const &usrllh)\n"
    "    GPS_SpaceNode< double >::float_t SpaceNode.tropo_correction(GPS_SpaceNode< double >::xyz_t const &sat, GPS_SpaceNode< double >::xyz_t const &usr)\n");
  
  return Qnil;
}

.tropo_correction_zenith_hydrostatic_Saastamoinen(*args) ⇒ Object

call-seq:

tropo_correction_zenith_hydrostatic_Saastamoinen(GPS_SpaceNode< double >::float_t const & latitude, GPS_SpaceNode< double >::float_t const & p_hpa,
GPS_SpaceNode< double >::float_t const & height_km) -> GPS_SpaceNode< double >::float_t

A class method.



9088
9089
9090
9091
9092
9093
9094
9095
9096
9097
9098
9099
9100
9101
9102
9103
9104
9105
9106
9107
9108
9109
9110
9111
9112
9113
9114
9115
9116
9117
9118
9119
9120
9121
9122
9123
9124
9125
9126
9127
9128
9129
9130
9131
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9088

SWIGINTERN VALUE
_wrap_SpaceNode_tropo_correction_zenith_hydrostatic_Saastamoinen(int argc, VALUE *argv, VALUE self) {
  GPS_SpaceNode< double >::float_t *arg1 = 0 ;
  GPS_SpaceNode< double >::float_t *arg2 = 0 ;
  GPS_SpaceNode< double >::float_t *arg3 = 0 ;
  GPS_SpaceNode< double >::float_t temp1 ;
  double val1 ;
  int ecode1 = 0 ;
  GPS_SpaceNode< double >::float_t temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  GPS_SpaceNode< double >::float_t temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  GPS_SpaceNode< double >::float_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::float_t","GPS_SpaceNode<(double)>::tropo_correction_zenith_hydrostatic_Saastamoinen", 1, argv[0] ));
  } 
  temp1 = static_cast< GPS_SpaceNode< double >::float_t >(val1);
  arg1 = &temp1;
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::float_t","GPS_SpaceNode<(double)>::tropo_correction_zenith_hydrostatic_Saastamoinen", 2, argv[1] ));
  } 
  temp2 = static_cast< GPS_SpaceNode< double >::float_t >(val2);
  arg2 = &temp2;
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::float_t","GPS_SpaceNode<(double)>::tropo_correction_zenith_hydrostatic_Saastamoinen", 3, argv[2] ));
  } 
  temp3 = static_cast< GPS_SpaceNode< double >::float_t >(val3);
  arg3 = &temp3;
  result = (GPS_SpaceNode< double >::float_t)GPS_SpaceNode< double >::SWIGTEMPLATEDISAMBIGUATOR tropo_correction_zenith_hydrostatic_Saastamoinen((double const &)*arg1,(double const &)*arg2,(double const &)*arg3);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

Instance Method Details

#ephemeris(*args) ⇒ Object

call-seq:

ephemeris(int const & prn) -> Ephemeris

An instance method.



9410
9411
9412
9413
9414
9415
9416
9417
9418
9419
9420
9421
9422
9423
9424
9425
9426
9427
9428
9429
9430
9431
9432
9433
9434
9435
9436
9437
9438
9439
9440
9441
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9410

SWIGINTERN VALUE
_wrap_SpaceNode_ephemeris(int argc, VALUE *argv, VALUE self) {
  GPS_SpaceNode< double > *arg1 = (GPS_SpaceNode< double > *) 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  GPS_Ephemeris< double > result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SpaceNodeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SpaceNode< double > const *","ephemeris", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_SpaceNode< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","ephemeris", 2, argv[0] ));
  } 
  temp2 = static_cast< int >(val2);
  arg2 = &temp2;
  result = GPS_SpaceNode_Sl_double_Sg__ephemeris((GPS_SpaceNode< double > const *)arg1,(int const &)*arg2);
  vresult = SWIG_NewPointerObj((new GPS_Ephemeris< double >(static_cast< const GPS_Ephemeris< double >& >(result))), SWIGTYPE_p_GPS_EphemerisT_double_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#has_satellite(*args) ⇒ Object

call-seq:

has_satellite(int const & prn) -> bool

An instance method.



8231
8232
8233
8234
8235
8236
8237
8238
8239
8240
8241
8242
8243
8244
8245
8246
8247
8248
8249
8250
8251
8252
8253
8254
8255
8256
8257
8258
8259
8260
8261
8262
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8231

SWIGINTERN VALUE
_wrap_SpaceNode_has_satellite(int argc, VALUE *argv, VALUE self) {
  GPS_SpaceNode< double > *arg1 = (GPS_SpaceNode< double > *) 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SpaceNodeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SpaceNode< double > const *","has_satellite", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_SpaceNode< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","has_satellite", 2, argv[0] ));
  } 
  temp2 = static_cast< int >(val2);
  arg2 = &temp2;
  result = (bool)((GPS_SpaceNode< double > const *)arg1)->has_satellite((int const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#iono_correction(*args, self) ⇒ Object

call-seq:

iono_correction(ENU relative_pos, LLH usrllh, Time t) -> GPS_SpaceNode< double >::float_t
iono_correction(XYZ sat, XYZ usr, Time t) -> GPS_SpaceNode< double >::float_t

An instance method.



8961
8962
8963
8964
8965
8966
8967
8968
8969
8970
8971
8972
8973
8974
8975
8976
8977
8978
8979
8980
8981
8982
8983
8984
8985
8986
8987
8988
8989
8990
8991
8992
8993
8994
8995
8996
8997
8998
8999
9000
9001
9002
9003
9004
9005
9006
9007
9008
9009
9010
9011
9012
9013
9014
9015
9016
9017
9018
9019
9020
9021
9022
9023
9024
9025
9026
9027
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8961

SWIGINTERN VALUE _wrap_SpaceNode_iono_correction(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_SpaceNodeT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_System_ENUT_double_WGS84_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_System_LLHT_double_WGS84_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SpaceNode_iono_correction__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_SpaceNodeT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SpaceNode_iono_correction__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SpaceNode.iono_correction", 
    "    GPS_SpaceNode< double >::float_t SpaceNode.iono_correction(GPS_SpaceNode< double >::enu_t const &relative_pos, GPS_SpaceNode< double >::llh_t const &usrllh, GPS_SpaceNode< double >::gps_time_t const &t)\n"
    "    GPS_SpaceNode< double >::float_t SpaceNode.iono_correction(GPS_SpaceNode< double >::xyz_t const &sat, GPS_SpaceNode< double >::xyz_t const &usr, GPS_SpaceNode< double >::gps_time_t const &t)\n");
  
  return Qnil;
}

#iono_utc(*args) ⇒ Object

call-seq:

iono_utc -> GPS_SpaceNode< double >::Ionospheric_UTC_Parameters const &

An instance method.



7846
7847
7848
7849
7850
7851
7852
7853
7854
7855
7856
7857
7858
7859
7860
7861
7862
7863
7864
7865
7866
7867
7868
7869
7870
7871
7872
7873
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7846

SWIGINTERN VALUE
_wrap_SpaceNode_iono_utc(int argc, VALUE *argv, VALUE self) {
  GPS_SpaceNode< double > *arg1 = (GPS_SpaceNode< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GPS_SpaceNode< double >::Ionospheric_UTC_Parameters *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SpaceNodeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SpaceNode< double > const *","iono_utc", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_SpaceNode< double > * >(argp1);
  result = (GPS_SpaceNode< double >::Ionospheric_UTC_Parameters *) &((GPS_SpaceNode< double > const *)arg1)->iono_utc();
  {
    vresult = SWIG_NewPointerObj(
      reinterpret_cast< GPS_Ionospheric_UTC_Parameters<double> * >(result),
      SWIGTYPE_p_GPS_Ionospheric_UTC_ParametersT_double_t, 0)
    
    ;
  }
  return vresult;
fail:
  return Qnil;
}

#is_valid_iono(*args) ⇒ Object

call-seq:

is_valid_iono -> bool

An instance method.



7885
7886
7887
7888
7889
7890
7891
7892
7893
7894
7895
7896
7897
7898
7899
7900
7901
7902
7903
7904
7905
7906
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7885

SWIGINTERN VALUE
_wrap_SpaceNode_is_valid_iono(int argc, VALUE *argv, VALUE self) {
  GPS_SpaceNode< double > *arg1 = (GPS_SpaceNode< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SpaceNodeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SpaceNode< double > const *","is_valid_iono", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_SpaceNode< double > * >(argp1);
  result = (bool)((GPS_SpaceNode< double > const *)arg1)->is_valid_iono();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#is_valid_iono_utc(*args) ⇒ Object

call-seq:

is_valid_iono_utc -> bool

An instance method.



7951
7952
7953
7954
7955
7956
7957
7958
7959
7960
7961
7962
7963
7964
7965
7966
7967
7968
7969
7970
7971
7972
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7951

SWIGINTERN VALUE
_wrap_SpaceNode_is_valid_iono_utc(int argc, VALUE *argv, VALUE self) {
  GPS_SpaceNode< double > *arg1 = (GPS_SpaceNode< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SpaceNodeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SpaceNode< double > const *","is_valid_iono_utc", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_SpaceNode< double > * >(argp1);
  result = (bool)((GPS_SpaceNode< double > const *)arg1)->is_valid_iono_utc();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#is_valid_utc(*args) ⇒ Object

call-seq:

is_valid_utc -> bool

An instance method.



7918
7919
7920
7921
7922
7923
7924
7925
7926
7927
7928
7929
7930
7931
7932
7933
7934
7935
7936
7937
7938
7939
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7918

SWIGINTERN VALUE
_wrap_SpaceNode_is_valid_utc(int argc, VALUE *argv, VALUE self) {
  GPS_SpaceNode< double > *arg1 = (GPS_SpaceNode< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SpaceNodeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SpaceNode< double > const *","is_valid_utc", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_SpaceNode< double > * >(argp1);
  result = (bool)((GPS_SpaceNode< double > const *)arg1)->is_valid_utc();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#merge(*args, self) ⇒ Object

call-seq:

merge(SpaceNode another, bool const & keep_original=True)
merge(SpaceNode another)

An instance method.



8390
8391
8392
8393
8394
8395
8396
8397
8398
8399
8400
8401
8402
8403
8404
8405
8406
8407
8408
8409
8410
8411
8412
8413
8414
8415
8416
8417
8418
8419
8420
8421
8422
8423
8424
8425
8426
8427
8428
8429
8430
8431
8432
8433
8434
8435
8436
8437
8438
8439
8440
8441
8442
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8390

SWIGINTERN VALUE _wrap_SpaceNode_merge(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_SpaceNodeT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPS_SpaceNodeT_double_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SpaceNode_merge__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_SpaceNodeT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPS_SpaceNodeT_double_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SpaceNode_merge__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SpaceNode.merge", 
    "    void SpaceNode.merge(GPS_SpaceNode< double >::self_t const &another, bool const &keep_original)\n"
    "    void SpaceNode.merge(GPS_SpaceNode< double >::self_t const &another)\n");
  
  return Qnil;
}

#read(*args) ⇒ Object

call-seq:

read(char const * fname) -> int

An instance method.



9453
9454
9455
9456
9457
9458
9459
9460
9461
9462
9463
9464
9465
9466
9467
9468
9469
9470
9471
9472
9473
9474
9475
9476
9477
9478
9479
9480
9481
9482
9483
9484
9485
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9453

SWIGINTERN VALUE
_wrap_SpaceNode_read(int argc, VALUE *argv, VALUE self) {
  GPS_SpaceNode< double > *arg1 = (GPS_SpaceNode< double > *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SpaceNodeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SpaceNode< double > *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_SpaceNode< double > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","read", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (int)GPS_SpaceNode_Sl_double_Sg__read(arg1,(char const *)arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}

#register_ephemeris(*args, self) ⇒ Object

call-seq:

register_ephemeris(int const & prn, Ephemeris eph, int const & priority_delta=1)
register_ephemeris(int const & prn, Ephemeris eph)

An instance method.



9334
9335
9336
9337
9338
9339
9340
9341
9342
9343
9344
9345
9346
9347
9348
9349
9350
9351
9352
9353
9354
9355
9356
9357
9358
9359
9360
9361
9362
9363
9364
9365
9366
9367
9368
9369
9370
9371
9372
9373
9374
9375
9376
9377
9378
9379
9380
9381
9382
9383
9384
9385
9386
9387
9388
9389
9390
9391
9392
9393
9394
9395
9396
9397
9398
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9334

SWIGINTERN VALUE _wrap_SpaceNode_register_ephemeris(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_SpaceNodeT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_GPS_EphemerisT_double_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SpaceNode_register_ephemeris__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_SpaceNodeT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_GPS_EphemerisT_double_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SpaceNode_register_ephemeris__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "register_ephemeris", 
    "    void register_ephemeris(int const &prn, GPS_Ephemeris< double > const &eph, int const &priority_delta)\n"
    "    void register_ephemeris(int const &prn, GPS_Ephemeris< double > const &eph)\n");
  
  return Qnil;
}

#update_all_ephemeris(*args) ⇒ Object

call-seq:

update_all_ephemeris(Time target_time)

An instance method.



8274
8275
8276
8277
8278
8279
8280
8281
8282
8283
8284
8285
8286
8287
8288
8289
8290
8291
8292
8293
8294
8295
8296
8297
8298
8299
8300
8301
8302
8303
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8274

SWIGINTERN VALUE
_wrap_SpaceNode_update_all_ephemeris(int argc, VALUE *argv, VALUE self) {
  GPS_SpaceNode< double > *arg1 = (GPS_SpaceNode< double > *) 0 ;
  GPS_SpaceNode< double >::gps_time_t *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SpaceNodeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SpaceNode< double > *","update_all_ephemeris", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_SpaceNode< double > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPS_TimeT_double_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::gps_time_t const &","update_all_ephemeris", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_SpaceNode< double >::gps_time_t const &","update_all_ephemeris", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< GPS_SpaceNode< double >::gps_time_t * >(argp2);
  (arg1)->update_all_ephemeris((GPS_SpaceNode< double >::gps_time_t const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}

#update_iono_utc(*args, self) ⇒ Object

call-seq:

update_iono_utc(GPS_SpaceNode< double >::Ionospheric_UTC_Parameters const & params, bool const & iono_valid=True,
bool const & utc_valid=True) -> GPS_SpaceNode< double >::Ionospheric_UTC_Parameters const &
update_iono_utc(GPS_SpaceNode< double >::Ionospheric_UTC_Parameters const & params, bool const & iono_valid=True) -> GPS_SpaceNode< double >::Ionospheric_UTC_Parameters const
update_iono_utc(GPS_SpaceNode< double >::Ionospheric_UTC_Parameters const & params) -> GPS_SpaceNode< double >::Ionospheric_UTC_Parameters const

An instance method.



8140
8141
8142
8143
8144
8145
8146
8147
8148
8149
8150
8151
8152
8153
8154
8155
8156
8157
8158
8159
8160
8161
8162
8163
8164
8165
8166
8167
8168
8169
8170
8171
8172
8173
8174
8175
8176
8177
8178
8179
8180
8181
8182
8183
8184
8185
8186
8187
8188
8189
8190
8191
8192
8193
8194
8195
8196
8197
8198
8199
8200
8201
8202
8203
8204
8205
8206
8207
8208
8209
8210
8211
8212
8213
8214
8215
8216
8217
8218
8219
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8140

SWIGINTERN VALUE _wrap_SpaceNode_update_iono_utc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_SpaceNodeT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SpaceNode_update_iono_utc__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_SpaceNodeT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SpaceNode_update_iono_utc__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_SpaceNodeT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SpaceNode_update_iono_utc__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SpaceNode.update_iono_utc", 
    "    GPS_SpaceNode< double >::Ionospheric_UTC_Parameters const SpaceNode.update_iono_utc(GPS_SpaceNode< double >::Ionospheric_UTC_Parameters const &params, bool const &iono_valid, bool const &utc_valid)\n"
    "    GPS_SpaceNode< double >::Ionospheric_UTC_Parameters const SpaceNode.update_iono_utc(GPS_SpaceNode< double >::Ionospheric_UTC_Parameters const &params, bool const &iono_valid)\n"
    "    GPS_SpaceNode< double >::Ionospheric_UTC_Parameters const & SpaceNode.update_iono_utc(GPS_SpaceNode< double >::Ionospheric_UTC_Parameters const &params)\n");
  
  return Qnil;
}