Class: GPS_PVT::GPS::Ephemeris

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::Ephemeris class

Instance Method Summary collapse

Constructor Details

#initialize(*args, self) ⇒ Object 



9836
9837
9838
9839
9840
9841
9842
9843
9844
9845
9846
9847
9848
9849
9850
9851
9852
9853
9854
9855
9856
9857
9858
9859
9860
9861
9862
9863
9864
9865
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9836

SWIGINTERN VALUE _wrap_new_Ephemeris(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Ephemeris__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Ephemeris__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Ephemeris.new", 
    "    Ephemeris.new()\n"
    "    Ephemeris.new(GPS_SpaceNode< double >::SatelliteProperties::Ephemeris const &eph)\n");
  
  return Qnil;
}

Instance Method Details

#a_f0(*args) ⇒ Object

call-seq:

a_f0 -> double const &

An instance method.



10775
10776
10777
10778
10779
10780
10781
10782
10783
10784
10785
10786
10787
10788
10789
10790
10791
10792
10793
10794
10795
10796
10797
10798
10799
10800
10801
10802
10803
10804
10805
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10775

SWIGINTERN VALUE
_wrap_Ephemeris_a_f0(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_a_f0", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_a_f0((GPS_Ephemeris< 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;
}

#a_f0=(*args) ⇒ Object

call-seq:

a_f0=(double const & v) -> double

An instance method.



10723
10724
10725
10726
10727
10728
10729
10730
10731
10732
10733
10734
10735
10736
10737
10738
10739
10740
10741
10742
10743
10744
10745
10746
10747
10748
10749
10750
10751
10752
10753
10754
10755
10756
10757
10758
10759
10760
10761
10762
10763
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10723

SWIGINTERN VALUE
_wrap_Ephemeris_a_f0e___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_a_f0", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_a_f0", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_a_f0(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#a_f1(*args) ⇒ Object

call-seq:

a_f1 -> double const &

An instance method.



10681
10682
10683
10684
10685
10686
10687
10688
10689
10690
10691
10692
10693
10694
10695
10696
10697
10698
10699
10700
10701
10702
10703
10704
10705
10706
10707
10708
10709
10710
10711
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10681

SWIGINTERN VALUE
_wrap_Ephemeris_a_f1(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_a_f1", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_a_f1((GPS_Ephemeris< 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;
}

#a_f1=(*args) ⇒ Object

call-seq:

a_f1=(double const & v) -> double

An instance method.



10629
10630
10631
10632
10633
10634
10635
10636
10637
10638
10639
10640
10641
10642
10643
10644
10645
10646
10647
10648
10649
10650
10651
10652
10653
10654
10655
10656
10657
10658
10659
10660
10661
10662
10663
10664
10665
10666
10667
10668
10669
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10629

SWIGINTERN VALUE
_wrap_Ephemeris_a_f1e___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_a_f1", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_a_f1", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_a_f1(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#a_f2(*args) ⇒ Object

call-seq:

a_f2 -> double const &

An instance method.



10587
10588
10589
10590
10591
10592
10593
10594
10595
10596
10597
10598
10599
10600
10601
10602
10603
10604
10605
10606
10607
10608
10609
10610
10611
10612
10613
10614
10615
10616
10617
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10587

SWIGINTERN VALUE
_wrap_Ephemeris_a_f2(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_a_f2", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_a_f2((GPS_Ephemeris< 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;
}

#a_f2=(*args) ⇒ Object

call-seq:

a_f2=(double const & v) -> double

An instance method.



10535
10536
10537
10538
10539
10540
10541
10542
10543
10544
10545
10546
10547
10548
10549
10550
10551
10552
10553
10554
10555
10556
10557
10558
10559
10560
10561
10562
10563
10564
10565
10566
10567
10568
10569
10570
10571
10572
10573
10574
10575
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10535

SWIGINTERN VALUE
_wrap_Ephemeris_a_f2e___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_a_f2", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_a_f2", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_a_f2(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#c_ic(*args) ⇒ Object

call-seq:

c_ic -> double const &

An instance method.



11809
11810
11811
11812
11813
11814
11815
11816
11817
11818
11819
11820
11821
11822
11823
11824
11825
11826
11827
11828
11829
11830
11831
11832
11833
11834
11835
11836
11837
11838
11839
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11809

SWIGINTERN VALUE
_wrap_Ephemeris_c_ic(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_c_ic", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_c_ic((GPS_Ephemeris< 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;
}

#c_ic=(*args) ⇒ Object

call-seq:

c_ic=(double const & v) -> double

An instance method.



11757
11758
11759
11760
11761
11762
11763
11764
11765
11766
11767
11768
11769
11770
11771
11772
11773
11774
11775
11776
11777
11778
11779
11780
11781
11782
11783
11784
11785
11786
11787
11788
11789
11790
11791
11792
11793
11794
11795
11796
11797
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11757

SWIGINTERN VALUE
_wrap_Ephemeris_c_ice___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_c_ic", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_c_ic", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_c_ic(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#c_is(*args) ⇒ Object

call-seq:

c_is -> double const &

An instance method.



11997
11998
11999
12000
12001
12002
12003
12004
12005
12006
12007
12008
12009
12010
12011
12012
12013
12014
12015
12016
12017
12018
12019
12020
12021
12022
12023
12024
12025
12026
12027
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11997

SWIGINTERN VALUE
_wrap_Ephemeris_c_is(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_c_is", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_c_is((GPS_Ephemeris< 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;
}

#c_is=(*args) ⇒ Object

call-seq:

c_is=(double const & v) -> double

An instance method.



11945
11946
11947
11948
11949
11950
11951
11952
11953
11954
11955
11956
11957
11958
11959
11960
11961
11962
11963
11964
11965
11966
11967
11968
11969
11970
11971
11972
11973
11974
11975
11976
11977
11978
11979
11980
11981
11982
11983
11984
11985
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11945

SWIGINTERN VALUE
_wrap_Ephemeris_c_ise___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_c_is", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_c_is", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_c_is(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#c_rc(*args) ⇒ Object

call-seq:

c_rc -> double const &

An instance method.



12185
12186
12187
12188
12189
12190
12191
12192
12193
12194
12195
12196
12197
12198
12199
12200
12201
12202
12203
12204
12205
12206
12207
12208
12209
12210
12211
12212
12213
12214
12215
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12185

SWIGINTERN VALUE
_wrap_Ephemeris_c_rc(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_c_rc", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_c_rc((GPS_Ephemeris< 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;
}

#c_rc=(*args) ⇒ Object

call-seq:

c_rc=(double const & v) -> double

An instance method.



12133
12134
12135
12136
12137
12138
12139
12140
12141
12142
12143
12144
12145
12146
12147
12148
12149
12150
12151
12152
12153
12154
12155
12156
12157
12158
12159
12160
12161
12162
12163
12164
12165
12166
12167
12168
12169
12170
12171
12172
12173
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12133

SWIGINTERN VALUE
_wrap_Ephemeris_c_rce___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_c_rc", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_c_rc", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_c_rc(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#c_rs(*args) ⇒ Object

call-seq:

c_rs -> double const &

An instance method.



10963
10964
10965
10966
10967
10968
10969
10970
10971
10972
10973
10974
10975
10976
10977
10978
10979
10980
10981
10982
10983
10984
10985
10986
10987
10988
10989
10990
10991
10992
10993
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10963

SWIGINTERN VALUE
_wrap_Ephemeris_c_rs(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_c_rs", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_c_rs((GPS_Ephemeris< 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;
}

#c_rs=(*args) ⇒ Object

call-seq:

c_rs=(double const & v) -> double

An instance method.



10911
10912
10913
10914
10915
10916
10917
10918
10919
10920
10921
10922
10923
10924
10925
10926
10927
10928
10929
10930
10931
10932
10933
10934
10935
10936
10937
10938
10939
10940
10941
10942
10943
10944
10945
10946
10947
10948
10949
10950
10951
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10911

SWIGINTERN VALUE
_wrap_Ephemeris_c_rse___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_c_rs", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_c_rs", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_c_rs(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#c_uc(*args) ⇒ Object

call-seq:

c_uc -> double const &

An instance method.



11245
11246
11247
11248
11249
11250
11251
11252
11253
11254
11255
11256
11257
11258
11259
11260
11261
11262
11263
11264
11265
11266
11267
11268
11269
11270
11271
11272
11273
11274
11275
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11245

SWIGINTERN VALUE
_wrap_Ephemeris_c_uc(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_c_uc", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_c_uc((GPS_Ephemeris< 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;
}

#c_uc=(*args) ⇒ Object

call-seq:

c_uc=(double const & v) -> double

An instance method.



11193
11194
11195
11196
11197
11198
11199
11200
11201
11202
11203
11204
11205
11206
11207
11208
11209
11210
11211
11212
11213
11214
11215
11216
11217
11218
11219
11220
11221
11222
11223
11224
11225
11226
11227
11228
11229
11230
11231
11232
11233
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11193

SWIGINTERN VALUE
_wrap_Ephemeris_c_uce___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_c_uc", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_c_uc", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_c_uc(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#c_us(*args) ⇒ Object

call-seq:

c_us -> double const &

An instance method.



11433
11434
11435
11436
11437
11438
11439
11440
11441
11442
11443
11444
11445
11446
11447
11448
11449
11450
11451
11452
11453
11454
11455
11456
11457
11458
11459
11460
11461
11462
11463
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11433

SWIGINTERN VALUE
_wrap_Ephemeris_c_us(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_c_us", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_c_us((GPS_Ephemeris< 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;
}

#c_us=(*args) ⇒ Object

call-seq:

c_us=(double const & v) -> double

An instance method.



11381
11382
11383
11384
11385
11386
11387
11388
11389
11390
11391
11392
11393
11394
11395
11396
11397
11398
11399
11400
11401
11402
11403
11404
11405
11406
11407
11408
11409
11410
11411
11412
11413
11414
11415
11416
11417
11418
11419
11420
11421
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11381

SWIGINTERN VALUE
_wrap_Ephemeris_c_use___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_c_us", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_c_us", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_c_us(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#consistent?(*args) ⇒ Boolean

call-seq:

consistent? -> bool

An instance method.

Returns:

  • (Boolean) 


9719
9720
9721
9722
9723
9724
9725
9726
9727
9728
9729
9730
9731
9732
9733
9734
9735
9736
9737
9738
9739
9740
9741
9742
9743
9744
9745
9746
9747
9748
9749
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9719

SWIGINTERN VALUE
_wrap_Ephemeris_consistentq___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< 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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","is_consistent", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (bool)((GPS_Ephemeris< double > const *)arg1)->is_consistent();
    } 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;
}

#constellation(*args, self) ⇒ Object

call-seq:

constellation(Time t, double const & pseudo_range=0, bool const & with_velocity=True)
constellation(Time t, double const & pseudo_range=0)
constellation(Time t)

An instance method.



12792
12793
12794
12795
12796
12797
12798
12799
12800
12801
12802
12803
12804
12805
12806
12807
12808
12809
12810
12811
12812
12813
12814
12815
12816
12817
12818
12819
12820
12821
12822
12823
12824
12825
12826
12827
12828
12829
12830
12831
12832
12833
12834
12835
12836
12837
12838
12839
12840
12841
12842
12843
12844
12845
12846
12847
12848
12849
12850
12851
12852
12853
12854
12855
12856
12857
12858
12859
12860
12861
12862
12863
12864
12865
12866
12867
12868
12869
12870
12871
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12792

SWIGINTERN VALUE _wrap_Ephemeris_constellation(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_EphemerisT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Ephemeris_constellation__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_EphemerisT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPS_TimeT_double_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_Ephemeris_constellation__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_EphemerisT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPS_TimeT_double_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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Ephemeris_constellation__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "constellation", 
    "    void constellation(System_XYZ< double,WGS84 > &position, System_XYZ< double,WGS84 > &velocity, GPS_Time< double > const &t, double const &pseudo_range, bool const &with_velocity)\n"
    "    void constellation(System_XYZ< double,WGS84 > &position, System_XYZ< double,WGS84 > &velocity, GPS_Time< double > const &t, double const &pseudo_range)\n"
    "    void constellation(System_XYZ< double,WGS84 > &position, System_XYZ< double,WGS84 > &velocity, GPS_Time< double > const &t)\n");
  
  return Qnil;
}

#delta_n(*args) ⇒ Object

call-seq:

delta_n -> double const &

An instance method.



11057
11058
11059
11060
11061
11062
11063
11064
11065
11066
11067
11068
11069
11070
11071
11072
11073
11074
11075
11076
11077
11078
11079
11080
11081
11082
11083
11084
11085
11086
11087
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11057

SWIGINTERN VALUE
_wrap_Ephemeris_delta_n(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_delta_n", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_delta_n((GPS_Ephemeris< 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;
}

#delta_n=(*args) ⇒ Object

call-seq:

delta_n=(double const & v) -> double

An instance method.



11005
11006
11007
11008
11009
11010
11011
11012
11013
11014
11015
11016
11017
11018
11019
11020
11021
11022
11023
11024
11025
11026
11027
11028
11029
11030
11031
11032
11033
11034
11035
11036
11037
11038
11039
11040
11041
11042
11043
11044
11045
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11005

SWIGINTERN VALUE
_wrap_Ephemeris_delta_ne___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_delta_n", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_delta_n", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_delta_n(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#dot_i0(*args) ⇒ Object

call-seq:

dot_i0 -> double const &

An instance method.



12467
12468
12469
12470
12471
12472
12473
12474
12475
12476
12477
12478
12479
12480
12481
12482
12483
12484
12485
12486
12487
12488
12489
12490
12491
12492
12493
12494
12495
12496
12497
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12467

SWIGINTERN VALUE
_wrap_Ephemeris_dot_i0(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_dot_i0", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_dot_i0((GPS_Ephemeris< 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;
}

#dot_i0=(*args) ⇒ Object

call-seq:

dot_i0=(double const & v) -> double

An instance method.



12415
12416
12417
12418
12419
12420
12421
12422
12423
12424
12425
12426
12427
12428
12429
12430
12431
12432
12433
12434
12435
12436
12437
12438
12439
12440
12441
12442
12443
12444
12445
12446
12447
12448
12449
12450
12451
12452
12453
12454
12455
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12415

SWIGINTERN VALUE
_wrap_Ephemeris_dot_i0e___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_dot_i0", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_dot_i0", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_dot_i0(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#dot_Omega0(*args) ⇒ Object

call-seq:

dot_Omega0 -> double const &

An instance method.



12373
12374
12375
12376
12377
12378
12379
12380
12381
12382
12383
12384
12385
12386
12387
12388
12389
12390
12391
12392
12393
12394
12395
12396
12397
12398
12399
12400
12401
12402
12403
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12373

SWIGINTERN VALUE
_wrap_Ephemeris_dot_Omega0(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_dot_Omega0", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_dot_Omega0((GPS_Ephemeris< 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;
}

#dot_Omega0=(*args) ⇒ Object

call-seq:

dot_Omega0=(double const & v) -> double

An instance method.



12321
12322
12323
12324
12325
12326
12327
12328
12329
12330
12331
12332
12333
12334
12335
12336
12337
12338
12339
12340
12341
12342
12343
12344
12345
12346
12347
12348
12349
12350
12351
12352
12353
12354
12355
12356
12357
12358
12359
12360
12361
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12321

SWIGINTERN VALUE
_wrap_Ephemeris_dot_Omega0e___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_dot_Omega0", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_dot_Omega0", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_dot_Omega0(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#e(*args) ⇒ Object

call-seq:

e -> double const &

An instance method.



11339
11340
11341
11342
11343
11344
11345
11346
11347
11348
11349
11350
11351
11352
11353
11354
11355
11356
11357
11358
11359
11360
11361
11362
11363
11364
11365
11366
11367
11368
11369
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11339

SWIGINTERN VALUE
_wrap_Ephemeris_e(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_e", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_e((GPS_Ephemeris< 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;
}

#e=(*args) ⇒ Object

call-seq:

e=(double const & v) -> double

An instance method.



11287
11288
11289
11290
11291
11292
11293
11294
11295
11296
11297
11298
11299
11300
11301
11302
11303
11304
11305
11306
11307
11308
11309
11310
11311
11312
11313
11314
11315
11316
11317
11318
11319
11320
11321
11322
11323
11324
11325
11326
11327
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11287

SWIGINTERN VALUE
_wrap_Ephemeris_ee___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_e", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_e", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_e(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#fit_interval(*args) ⇒ Object

call-seq:

fit_interval -> double const &

An instance method.



11715
11716
11717
11718
11719
11720
11721
11722
11723
11724
11725
11726
11727
11728
11729
11730
11731
11732
11733
11734
11735
11736
11737
11738
11739
11740
11741
11742
11743
11744
11745
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11715

SWIGINTERN VALUE
_wrap_Ephemeris_fit_interval(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_fit_interval", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_fit_interval((GPS_Ephemeris< 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;
}

#fit_interval=(*args) ⇒ Object

call-seq:

fit_interval=(double const & v) -> double

An instance method.



11663
11664
11665
11666
11667
11668
11669
11670
11671
11672
11673
11674
11675
11676
11677
11678
11679
11680
11681
11682
11683
11684
11685
11686
11687
11688
11689
11690
11691
11692
11693
11694
11695
11696
11697
11698
11699
11700
11701
11702
11703
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11663

SWIGINTERN VALUE
_wrap_Ephemeris_fit_intervale___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_fit_interval", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_fit_interval", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_fit_interval(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#i0(*args) ⇒ Object

call-seq:

i0 -> double const &

An instance method.



12091
12092
12093
12094
12095
12096
12097
12098
12099
12100
12101
12102
12103
12104
12105
12106
12107
12108
12109
12110
12111
12112
12113
12114
12115
12116
12117
12118
12119
12120
12121
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12091

SWIGINTERN VALUE
_wrap_Ephemeris_i0(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_i0", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_i0((GPS_Ephemeris< 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;
}

#i0=(*args) ⇒ Object

call-seq:

i0=(double const & v) -> double

An instance method.



12039
12040
12041
12042
12043
12044
12045
12046
12047
12048
12049
12050
12051
12052
12053
12054
12055
12056
12057
12058
12059
12060
12061
12062
12063
12064
12065
12066
12067
12068
12069
12070
12071
12072
12073
12074
12075
12076
12077
12078
12079
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12039

SWIGINTERN VALUE
_wrap_Ephemeris_i0e___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_i0", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_i0", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_i0(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#invalidate(*args) ⇒ Object

call-seq:

invalidate

An instance method.



9680
9681
9682
9683
9684
9685
9686
9687
9688
9689
9690
9691
9692
9693
9694
9695
9696
9697
9698
9699
9700
9701
9702
9703
9704
9705
9706
9707
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9680

SWIGINTERN VALUE
_wrap_Ephemeris_invalidate(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","invalidate", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      (arg1)->invalidate();
    } 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;
}

#iodc(*args) ⇒ Object

call-seq:

iodc -> int const &

An instance method.



10305
10306
10307
10308
10309
10310
10311
10312
10313
10314
10315
10316
10317
10318
10319
10320
10321
10322
10323
10324
10325
10326
10327
10328
10329
10330
10331
10332
10333
10334
10335
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10305

SWIGINTERN VALUE
_wrap_Ephemeris_iodc(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_iodc", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (int *) &GPS_Ephemeris_Sl_double_Sg__get_iodc((GPS_Ephemeris< 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_int(static_cast< int >(*result));
  return vresult;
fail:
  return Qnil;
}

#iodc=(*args) ⇒ Object

call-seq:

iodc=(int const & v) -> int

An instance method.



10253
10254
10255
10256
10257
10258
10259
10260
10261
10262
10263
10264
10265
10266
10267
10268
10269
10270
10271
10272
10273
10274
10275
10276
10277
10278
10279
10280
10281
10282
10283
10284
10285
10286
10287
10288
10289
10290
10291
10292
10293
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10253

SWIGINTERN VALUE
_wrap_Ephemeris_iodce___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val2 ;
  int ecode2 = 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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_iodc", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","set_iodc", 2, argv[0] ));
  } 
  temp2 = static_cast< int >(val2);
  arg2 = &temp2;
  {
    try {
      result = (int)GPS_Ephemeris_Sl_double_Sg__set_iodc(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_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#iode(*args) ⇒ Object

call-seq:

iode -> int const &

An instance method.



10869
10870
10871
10872
10873
10874
10875
10876
10877
10878
10879
10880
10881
10882
10883
10884
10885
10886
10887
10888
10889
10890
10891
10892
10893
10894
10895
10896
10897
10898
10899
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10869

SWIGINTERN VALUE
_wrap_Ephemeris_iode(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_iode", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (int *) &GPS_Ephemeris_Sl_double_Sg__get_iode((GPS_Ephemeris< 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_int(static_cast< int >(*result));
  return vresult;
fail:
  return Qnil;
}

#iode=(*args) ⇒ Object

call-seq:

iode=(int const & v) -> int

An instance method.



10817
10818
10819
10820
10821
10822
10823
10824
10825
10826
10827
10828
10829
10830
10831
10832
10833
10834
10835
10836
10837
10838
10839
10840
10841
10842
10843
10844
10845
10846
10847
10848
10849
10850
10851
10852
10853
10854
10855
10856
10857
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10817

SWIGINTERN VALUE
_wrap_Ephemeris_iodee___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val2 ;
  int ecode2 = 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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_iode", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","set_iode", 2, argv[0] ));
  } 
  temp2 = static_cast< int >(val2);
  arg2 = &temp2;
  {
    try {
      result = (int)GPS_Ephemeris_Sl_double_Sg__set_iode(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_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#iode_subframe3(*args) ⇒ Object

call-seq:

iode_subframe3 -> int

Get value of attribute.



9647
9648
9649
9650
9651
9652
9653
9654
9655
9656
9657
9658
9659
9660
9661
9662
9663
9664
9665
9666
9667
9668
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9647

SWIGINTERN VALUE
_wrap_Ephemeris_iode_subframe3_get(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int 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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","iode_subframe3", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  result = (int) ((arg1)->iode_subframe3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#iode_subframe3=(*args) ⇒ Object

call-seq:

iode_subframe3=(x) -> int

Set new value for attribute.



9618
9619
9620
9621
9622
9623
9624
9625
9626
9627
9628
9629
9630
9631
9632
9633
9634
9635
9636
9637
9638
9639
9640
9641
9642
9643
9644
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9618

SWIGINTERN VALUE
_wrap_Ephemeris_iode_subframe3_set(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","iode_subframe3", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","iode_subframe3", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iode_subframe3 = arg2;
  return Qnil;
fail:
  return Qnil;
}

#M0(*args) ⇒ Object

call-seq:

M0 -> double const &

An instance method.



11151
11152
11153
11154
11155
11156
11157
11158
11159
11160
11161
11162
11163
11164
11165
11166
11167
11168
11169
11170
11171
11172
11173
11174
11175
11176
11177
11178
11179
11180
11181
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11151

SWIGINTERN VALUE
_wrap_Ephemeris_M0(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_M0", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_M0((GPS_Ephemeris< 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;
}

#M0=(*args) ⇒ Object

call-seq:

M0=(double const & v) -> double

An instance method.



11099
11100
11101
11102
11103
11104
11105
11106
11107
11108
11109
11110
11111
11112
11113
11114
11115
11116
11117
11118
11119
11120
11121
11122
11123
11124
11125
11126
11127
11128
11129
11130
11131
11132
11133
11134
11135
11136
11137
11138
11139
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11099

SWIGINTERN VALUE
_wrap_Ephemeris_M0e___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_M0", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_M0", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_M0(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#omega(*args) ⇒ Object

call-seq:

omega -> double const &

An instance method.



12279
12280
12281
12282
12283
12284
12285
12286
12287
12288
12289
12290
12291
12292
12293
12294
12295
12296
12297
12298
12299
12300
12301
12302
12303
12304
12305
12306
12307
12308
12309
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12279

SWIGINTERN VALUE
_wrap_Ephemeris_omega(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_omega", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_omega((GPS_Ephemeris< 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;
}

#Omega0(*args) ⇒ Object

call-seq:

Omega0 -> double const &

An instance method.



11903
11904
11905
11906
11907
11908
11909
11910
11911
11912
11913
11914
11915
11916
11917
11918
11919
11920
11921
11922
11923
11924
11925
11926
11927
11928
11929
11930
11931
11932
11933
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11903

SWIGINTERN VALUE
_wrap_Ephemeris_Omega0(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_Omega0", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_Omega0((GPS_Ephemeris< 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;
}

#Omega0=(*args) ⇒ Object

call-seq:

Omega0=(double const & v) -> double

An instance method.



11851
11852
11853
11854
11855
11856
11857
11858
11859
11860
11861
11862
11863
11864
11865
11866
11867
11868
11869
11870
11871
11872
11873
11874
11875
11876
11877
11878
11879
11880
11881
11882
11883
11884
11885
11886
11887
11888
11889
11890
11891
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11851

SWIGINTERN VALUE
_wrap_Ephemeris_Omega0e___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_Omega0", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_Omega0", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_Omega0(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#omega=(*args) ⇒ Object

call-seq:

omega=(double const & v) -> double

An instance method.



12227
12228
12229
12230
12231
12232
12233
12234
12235
12236
12237
12238
12239
12240
12241
12242
12243
12244
12245
12246
12247
12248
12249
12250
12251
12252
12253
12254
12255
12256
12257
12258
12259
12260
12261
12262
12263
12264
12265
12266
12267
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12227

SWIGINTERN VALUE
_wrap_Ephemeris_omegae___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_omega", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_omega", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_omega(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#parse(*args) ⇒ Object

call-seq:

parse(unsigned int const [10] buf)

An instance method.



12509
12510
12511
12512
12513
12514
12515
12516
12517
12518
12519
12520
12521
12522
12523
12524
12525
12526
12527
12528
12529
12530
12531
12532
12533
12534
12535
12536
12537
12538
12539
12540
12541
12542
12543
12544
12545
12546
12547
12548
12549
12550
12551
12552
12553
12554
12555
12556
12557
12558
12559
12560
12561
12562
12563
12564
12565
12566
12567
12568
12569
12570
12571
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12509

SWIGINTERN VALUE
_wrap_Ephemeris_parse(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  unsigned int *arg2 ;
  int *arg3 = (int *) 0 ;
  int *arg4 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int temp2[10] ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  int temp4 ;
  int res4 = SWIG_TMPOBJ ;
  VALUE vresult = Qnil;
  
  arg3 = &temp3;
  arg4 = &temp4;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","parse", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    if(!(RB_TYPE_P(argv[0], T_ARRAY) && (RARRAY_LEN(argv[0]) == 10))){
      SWIG_exception(SWIG_TypeError, "array[10] is expected");
    }
    for(int i(0); i < 10; ++i){
      if(!SWIG_IsOK(SWIG_AsVal_unsigned_SS_int (RARRAY_AREF(argv[0], i), &temp2[i]))){
        SWIG_exception(SWIG_TypeError, "unsigned int is expected");
      }
    }
    arg2 = temp2;
  }
  {
    try {
      GPS_Ephemeris_Sl_double_Sg__parse(arg1,(unsigned int const (*))arg2,arg3,arg4);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = rb_ary_new();
  if (SWIG_IsTmpObj(res3)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
  }
  if (SWIG_IsTmpObj(res4)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
  }
  return vresult;
fail:
  return Qnil;
}

#sqrt_A(*args) ⇒ Object

call-seq:

sqrt_A -> double const &

An instance method.



11527
11528
11529
11530
11531
11532
11533
11534
11535
11536
11537
11538
11539
11540
11541
11542
11543
11544
11545
11546
11547
11548
11549
11550
11551
11552
11553
11554
11555
11556
11557
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11527

SWIGINTERN VALUE
_wrap_Ephemeris_sqrt_A(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_sqrt_A", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_sqrt_A((GPS_Ephemeris< 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;
}

#sqrt_A=(*args) ⇒ Object

call-seq:

sqrt_A=(double const & v) -> double

An instance method.



11475
11476
11477
11478
11479
11480
11481
11482
11483
11484
11485
11486
11487
11488
11489
11490
11491
11492
11493
11494
11495
11496
11497
11498
11499
11500
11501
11502
11503
11504
11505
11506
11507
11508
11509
11510
11511
11512
11513
11514
11515
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11475

SWIGINTERN VALUE
_wrap_Ephemeris_sqrt_Ae___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_sqrt_A", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_sqrt_A", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_sqrt_A(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#SV_health(*args) ⇒ Object

call-seq:

SV_health -> unsigned int const &

An instance method.



10211
10212
10213
10214
10215
10216
10217
10218
10219
10220
10221
10222
10223
10224
10225
10226
10227
10228
10229
10230
10231
10232
10233
10234
10235
10236
10237
10238
10239
10240
10241
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10211

SWIGINTERN VALUE
_wrap_Ephemeris_SV_health(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_SV_health", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (unsigned int *) &GPS_Ephemeris_Sl_double_Sg__get_SV_health((GPS_Ephemeris< 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_unsigned_SS_int(static_cast< unsigned int >(*result));
  return vresult;
fail:
  return Qnil;
}

#SV_health=(*args) ⇒ Object

call-seq:

SV_health=(unsigned int const & v) -> unsigned int

An instance method.



10159
10160
10161
10162
10163
10164
10165
10166
10167
10168
10169
10170
10171
10172
10173
10174
10175
10176
10177
10178
10179
10180
10181
10182
10183
10184
10185
10186
10187
10188
10189
10190
10191
10192
10193
10194
10195
10196
10197
10198
10199
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10159

SWIGINTERN VALUE
_wrap_Ephemeris_SV_healthe___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  unsigned int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int temp2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned 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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_SV_health", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","set_SV_health", 2, argv[0] ));
  } 
  temp2 = static_cast< unsigned int >(val2);
  arg2 = &temp2;
  {
    try {
      result = (unsigned int)GPS_Ephemeris_Sl_double_Sg__set_SV_health(arg1,(unsigned 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_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

#svid(*args) ⇒ Object

call-seq:

svid -> unsigned int const &

An instance method.



9929
9930
9931
9932
9933
9934
9935
9936
9937
9938
9939
9940
9941
9942
9943
9944
9945
9946
9947
9948
9949
9950
9951
9952
9953
9954
9955
9956
9957
9958
9959
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9929

SWIGINTERN VALUE
_wrap_Ephemeris_svid(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_svid", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (unsigned int *) &GPS_Ephemeris_Sl_double_Sg__get_svid((GPS_Ephemeris< 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_unsigned_SS_int(static_cast< unsigned int >(*result));
  return vresult;
fail:
  return Qnil;
}

#svid=(*args) ⇒ Object

call-seq:

svid=(unsigned int const & v) -> unsigned int

An instance method.



9877
9878
9879
9880
9881
9882
9883
9884
9885
9886
9887
9888
9889
9890
9891
9892
9893
9894
9895
9896
9897
9898
9899
9900
9901
9902
9903
9904
9905
9906
9907
9908
9909
9910
9911
9912
9913
9914
9915
9916
9917
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9877

SWIGINTERN VALUE
_wrap_Ephemeris_svide___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  unsigned int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int temp2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned 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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_svid", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","set_svid", 2, argv[0] ));
  } 
  temp2 = static_cast< unsigned int >(val2);
  arg2 = &temp2;
  {
    try {
      result = (unsigned int)GPS_Ephemeris_Sl_double_Sg__set_svid(arg1,(unsigned 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_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

#t_GD(*args) ⇒ Object

call-seq:

t_GD -> double const &

An instance method.



10399
10400
10401
10402
10403
10404
10405
10406
10407
10408
10409
10410
10411
10412
10413
10414
10415
10416
10417
10418
10419
10420
10421
10422
10423
10424
10425
10426
10427
10428
10429
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10399

SWIGINTERN VALUE
_wrap_Ephemeris_t_GD(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_t_GD", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_t_GD((GPS_Ephemeris< 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;
}

#t_GD=(*args) ⇒ Object

call-seq:

t_GD=(double const & v) -> double

An instance method.



10347
10348
10349
10350
10351
10352
10353
10354
10355
10356
10357
10358
10359
10360
10361
10362
10363
10364
10365
10366
10367
10368
10369
10370
10371
10372
10373
10374
10375
10376
10377
10378
10379
10380
10381
10382
10383
10384
10385
10386
10387
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10347

SWIGINTERN VALUE
_wrap_Ephemeris_t_GDe___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_t_GD", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_t_GD", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_t_GD(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#t_oc(*args) ⇒ Object

call-seq:

t_oc -> double const &

An instance method.



10493
10494
10495
10496
10497
10498
10499
10500
10501
10502
10503
10504
10505
10506
10507
10508
10509
10510
10511
10512
10513
10514
10515
10516
10517
10518
10519
10520
10521
10522
10523
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10493

SWIGINTERN VALUE
_wrap_Ephemeris_t_oc(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_t_oc", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_t_oc((GPS_Ephemeris< 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;
}

#t_oc=(*args) ⇒ Object

call-seq:

t_oc=(double const & v) -> double

An instance method.



10441
10442
10443
10444
10445
10446
10447
10448
10449
10450
10451
10452
10453
10454
10455
10456
10457
10458
10459
10460
10461
10462
10463
10464
10465
10466
10467
10468
10469
10470
10471
10472
10473
10474
10475
10476
10477
10478
10479
10480
10481
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10441

SWIGINTERN VALUE
_wrap_Ephemeris_t_oce___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_t_oc", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_t_oc", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_t_oc(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#t_oe(*args) ⇒ Object

call-seq:

t_oe -> double const &

An instance method.



11621
11622
11623
11624
11625
11626
11627
11628
11629
11630
11631
11632
11633
11634
11635
11636
11637
11638
11639
11640
11641
11642
11643
11644
11645
11646
11647
11648
11649
11650
11651
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11621

SWIGINTERN VALUE
_wrap_Ephemeris_t_oe(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_t_oe", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_t_oe((GPS_Ephemeris< 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;
}

#t_oe=(*args) ⇒ Object

call-seq:

t_oe=(double const & v) -> double

An instance method.



11569
11570
11571
11572
11573
11574
11575
11576
11577
11578
11579
11580
11581
11582
11583
11584
11585
11586
11587
11588
11589
11590
11591
11592
11593
11594
11595
11596
11597
11598
11599
11600
11601
11602
11603
11604
11605
11606
11607
11608
11609
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11569

SWIGINTERN VALUE
_wrap_Ephemeris_t_oee___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_t_oe", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_t_oe", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ephemeris_Sl_double_Sg__set_t_oe(arg1,(double 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_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#URA(*args) ⇒ Object

call-seq:

URA -> int const &

An instance method.



10117
10118
10119
10120
10121
10122
10123
10124
10125
10126
10127
10128
10129
10130
10131
10132
10133
10134
10135
10136
10137
10138
10139
10140
10141
10142
10143
10144
10145
10146
10147
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10117

SWIGINTERN VALUE
_wrap_Ephemeris_URA(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_URA", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (int *) &GPS_Ephemeris_Sl_double_Sg__get_URA((GPS_Ephemeris< 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_int(static_cast< int >(*result));
  return vresult;
fail:
  return Qnil;
}

#URA=(*args) ⇒ Object

call-seq:

URA=(int const & v) -> int

An instance method.



10065
10066
10067
10068
10069
10070
10071
10072
10073
10074
10075
10076
10077
10078
10079
10080
10081
10082
10083
10084
10085
10086
10087
10088
10089
10090
10091
10092
10093
10094
10095
10096
10097
10098
10099
10100
10101
10102
10103
10104
10105
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10065

SWIGINTERN VALUE
_wrap_Ephemeris_URAe___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val2 ;
  int ecode2 = 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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_URA", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","set_URA", 2, argv[0] ));
  } 
  temp2 = static_cast< int >(val2);
  arg2 = &temp2;
  {
    try {
      result = (int)GPS_Ephemeris_Sl_double_Sg__set_URA(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_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#WN(*args) ⇒ Object

call-seq:

WN -> unsigned int const &

An instance method.



10023
10024
10025
10026
10027
10028
10029
10030
10031
10032
10033
10034
10035
10036
10037
10038
10039
10040
10041
10042
10043
10044
10045
10046
10047
10048
10049
10050
10051
10052
10053
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10023

SWIGINTERN VALUE
_wrap_Ephemeris_WN(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int *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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > const *","get_WN", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  {
    try {
      result = (unsigned int *) &GPS_Ephemeris_Sl_double_Sg__get_WN((GPS_Ephemeris< 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_unsigned_SS_int(static_cast< unsigned int >(*result));
  return vresult;
fail:
  return Qnil;
}

#WN=(*args) ⇒ Object

call-seq:

WN=(unsigned int const & v) -> unsigned int

An instance method.



9971
9972
9973
9974
9975
9976
9977
9978
9979
9980
9981
9982
9983
9984
9985
9986
9987
9988
9989
9990
9991
9992
9993
9994
9995
9996
9997
9998
9999
10000
10001
10002
10003
10004
10005
10006
10007
10008
10009
10010
10011
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9971

SWIGINTERN VALUE
_wrap_Ephemeris_WNe___(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  unsigned int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int temp2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned 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_EphemerisT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ephemeris< double > *","set_WN", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","set_WN", 2, argv[0] ));
  } 
  temp2 = static_cast< unsigned int >(val2);
  arg2 = &temp2;
  {
    try {
      result = (unsigned int)GPS_Ephemeris_Sl_double_Sg__set_WN(arg1,(unsigned 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_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}