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.



6598
6599
6600
6601
6602
6603
6604
6605
6606
6607
6608
6609
6610
6611
6612
6613
6614
6615
6616
6617
6618
6619
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6598

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;
  }
  {
    try {
      result = (GPS_SpaceNode< double > *)new GPS_SpaceNode< double >();
      DATA_PTR(self) = result;
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  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.



6521
6522
6523
6524
6525
6526
6527
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6521

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.



6539
6540
6541
6542
6543
6544
6545
6546
6547
6548
6549
6550
6551
6552
6553
6554
6555
6556
6557
6558
6559
6560
6561
6562
6563
6564
6565
6566
6567
6568
6569
6570
6571
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6539

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;
  {
    try {
      result = (GPS_SpaceNode< double >::float_t)GPS_SpaceNode< double >::SWIGTEMPLATEDISAMBIGUATOR gamma_per_L1((double const &)*arg1);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  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.



6372
6373
6374
6375
6376
6377
6378
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6372

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.



6390
6391
6392
6393
6394
6395
6396
6397
6398
6399
6400
6401
6402
6403
6404
6405
6406
6407
6408
6409
6410
6411
6412
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6390

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;
  }
  {
    try {
      result = (GPS_SpaceNode< double >::float_t *) &GPS_SpaceNode< double >::SWIGTEMPLATEDISAMBIGUATOR L1_WaveLength();
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  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.



6460
6461
6462
6463
6464
6465
6466
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6460

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.



6478
6479
6480
6481
6482
6483
6484
6485
6486
6487
6488
6489
6490
6491
6492
6493
6494
6495
6496
6497
6498
6499
6500
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6478

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;
  }
  {
    try {
      result = (GPS_SpaceNode< double >::float_t *) &GPS_SpaceNode< double >::SWIGTEMPLATEDISAMBIGUATOR L2_WaveLength();
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  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.



6345
6346
6347
6348
6349
6350
6351
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6345

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.



7455
7456
7457
7458
7459
7460
7461
7462
7463
7464
7465
7466
7467
7468
7469
7470
7471
7472
7473
7474
7475
7476
7477
7478
7479
7480
7481
7482
7483
7484
7485
7486
7487
7488
7489
7490
7491
7492
7493
7494
7495
7496
7497
7498
7499
7500
7501
7502
7503
7504
7505
7506
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7455

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.



6433
6434
6435
6436
6437
6438
6439
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6433

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.



7601
7602
7603
7604
7605
7606
7607
7608
7609
7610
7611
7612
7613
7614
7615
7616
7617
7618
7619
7620
7621
7622
7623
7624
7625
7626
7627
7628
7629
7630
7631
7632
7633
7634
7635
7636
7637
7638
7639
7640
7641
7642
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7601

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.



7735
7736
7737
7738
7739
7740
7741
7742
7743
7744
7745
7746
7747
7748
7749
7750
7751
7752
7753
7754
7755
7756
7757
7758
7759
7760
7761
7762
7763
7764
7765
7766
7767
7768
7769
7770
7771
7772
7773
7774
7775
7776
7777
7778
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7735

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.



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
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8171

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.



8059
8060
8061
8062
8063
8064
8065
8066
8067
8068
8069
8070
8071
8072
8073
8074
8075
8076
8077
8078
8079
8080
8081
8082
8083
8084
8085
8086
8087
8088
8089
8090
8091
8092
8093
8094
8095
8096
8097
8098
8099
8100
8101
8102
8103
8104
8105
8106
8107
8108
8109
8110
8111
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8059

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;
  {
    try {
      result = (GPS_SpaceNode< double >::float_t)GPS_SpaceNode< double >::SWIGTEMPLATEDISAMBIGUATOR tropo_correction_zenith_hydrostatic_Saastamoinen((double const &)*arg1,(double const &)*arg2,(double const &)*arg3);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  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.



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
8443
8444
8445
8446
8447
8448
8449
8450
8451
8452
8453
8454
8455
8456
8457
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8417

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;
  {
    try {
      result = GPS_SpaceNode_Sl_double_Sg__ephemeris((GPS_SpaceNode< double > const *)arg1,(int const &)*arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  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.



7085
7086
7087
7088
7089
7090
7091
7092
7093
7094
7095
7096
7097
7098
7099
7100
7101
7102
7103
7104
7105
7106
7107
7108
7109
7110
7111
7112
7113
7114
7115
7116
7117
7118
7119
7120
7121
7122
7123
7124
7125
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7085

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;
  {
    try {
      result = (bool)((GPS_SpaceNode< double > const *)arg1)->has_satellite((int const &)*arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  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.



7923
7924
7925
7926
7927
7928
7929
7930
7931
7932
7933
7934
7935
7936
7937
7938
7939
7940
7941
7942
7943
7944
7945
7946
7947
7948
7949
7950
7951
7952
7953
7954
7955
7956
7957
7958
7959
7960
7961
7962
7963
7964
7965
7966
7967
7968
7969
7970
7971
7972
7973
7974
7975
7976
7977
7978
7979
7980
7981
7982
7983
7984
7985
7986
7987
7988
7989
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7923

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.



6637
6638
6639
6640
6641
6642
6643
6644
6645
6646
6647
6648
6649
6650
6651
6652
6653
6654
6655
6656
6657
6658
6659
6660
6661
6662
6663
6664
6665
6666
6667
6668
6669
6670
6671
6672
6673
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6637

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);
  {
    try {
      result = (GPS_SpaceNode< double >::Ionospheric_UTC_Parameters *) &((GPS_SpaceNode< double > const *)arg1)->iono_utc();
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  {
    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.



6685
6686
6687
6688
6689
6690
6691
6692
6693
6694
6695
6696
6697
6698
6699
6700
6701
6702
6703
6704
6705
6706
6707
6708
6709
6710
6711
6712
6713
6714
6715
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6685

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);
  {
    try {
      result = (bool)((GPS_SpaceNode< double > const *)arg1)->is_valid_iono();
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  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.



6769
6770
6771
6772
6773
6774
6775
6776
6777
6778
6779
6780
6781
6782
6783
6784
6785
6786
6787
6788
6789
6790
6791
6792
6793
6794
6795
6796
6797
6798
6799
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6769

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);
  {
    try {
      result = (bool)((GPS_SpaceNode< double > const *)arg1)->is_valid_iono_utc();
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  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.



6727
6728
6729
6730
6731
6732
6733
6734
6735
6736
6737
6738
6739
6740
6741
6742
6743
6744
6745
6746
6747
6748
6749
6750
6751
6752
6753
6754
6755
6756
6757
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6727

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);
  {
    try {
      result = (bool)((GPS_SpaceNode< double > const *)arg1)->is_valid_utc();
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  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.



7280
7281
7282
7283
7284
7285
7286
7287
7288
7289
7290
7291
7292
7293
7294
7295
7296
7297
7298
7299
7300
7301
7302
7303
7304
7305
7306
7307
7308
7309
7310
7311
7312
7313
7314
7315
7316
7317
7318
7319
7320
7321
7322
7323
7324
7325
7326
7327
7328
7329
7330
7331
7332
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7280

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.



8469
8470
8471
8472
8473
8474
8475
8476
8477
8478
8479
8480
8481
8482
8483
8484
8485
8486
8487
8488
8489
8490
8491
8492
8493
8494
8495
8496
8497
8498
8499
8500
8501
8502
8503
8504
8505
8506
8507
8508
8509
8510
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8469

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);
  {
    try {
      result = (int)GPS_SpaceNode_Sl_double_Sg__read(arg1,(char const *)arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  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.



8341
8342
8343
8344
8345
8346
8347
8348
8349
8350
8351
8352
8353
8354
8355
8356
8357
8358
8359
8360
8361
8362
8363
8364
8365
8366
8367
8368
8369
8370
8371
8372
8373
8374
8375
8376
8377
8378
8379
8380
8381
8382
8383
8384
8385
8386
8387
8388
8389
8390
8391
8392
8393
8394
8395
8396
8397
8398
8399
8400
8401
8402
8403
8404
8405
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8341

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.



7137
7138
7139
7140
7141
7142
7143
7144
7145
7146
7147
7148
7149
7150
7151
7152
7153
7154
7155
7156
7157
7158
7159
7160
7161
7162
7163
7164
7165
7166
7167
7168
7169
7170
7171
7172
7173
7174
7175
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7137

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);
  {
    try {
      (arg1)->update_all_ephemeris((GPS_SpaceNode< double >::gps_time_t const &)*arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  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.



6994
6995
6996
6997
6998
6999
7000
7001
7002
7003
7004
7005
7006
7007
7008
7009
7010
7011
7012
7013
7014
7015
7016
7017
7018
7019
7020
7021
7022
7023
7024
7025
7026
7027
7028
7029
7030
7031
7032
7033
7034
7035
7036
7037
7038
7039
7040
7041
7042
7043
7044
7045
7046
7047
7048
7049
7050
7051
7052
7053
7054
7055
7056
7057
7058
7059
7060
7061
7062
7063
7064
7065
7066
7067
7068
7069
7070
7071
7072
7073
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6994

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;
}