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 



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

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.



11615
11616
11617
11618
11619
11620
11621
11622
11623
11624
11625
11626
11627
11628
11629
11630
11631
11632
11633
11634
11635
11636
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11615

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_a_f0((GPS_Ephemeris< double > const *)arg1);
  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.



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

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;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_a_f0(arg1,(double const &)*arg2);
  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.



11539
11540
11541
11542
11543
11544
11545
11546
11547
11548
11549
11550
11551
11552
11553
11554
11555
11556
11557
11558
11559
11560
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11539

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_a_f1((GPS_Ephemeris< double > const *)arg1);
  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.



11496
11497
11498
11499
11500
11501
11502
11503
11504
11505
11506
11507
11508
11509
11510
11511
11512
11513
11514
11515
11516
11517
11518
11519
11520
11521
11522
11523
11524
11525
11526
11527
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11496

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;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_a_f1(arg1,(double const &)*arg2);
  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.



11463
11464
11465
11466
11467
11468
11469
11470
11471
11472
11473
11474
11475
11476
11477
11478
11479
11480
11481
11482
11483
11484
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11463

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_a_f2((GPS_Ephemeris< double > const *)arg1);
  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.



11420
11421
11422
11423
11424
11425
11426
11427
11428
11429
11430
11431
11432
11433
11434
11435
11436
11437
11438
11439
11440
11441
11442
11443
11444
11445
11446
11447
11448
11449
11450
11451
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11420

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;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_a_f2(arg1,(double const &)*arg2);
  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.



12503
12504
12505
12506
12507
12508
12509
12510
12511
12512
12513
12514
12515
12516
12517
12518
12519
12520
12521
12522
12523
12524
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12503

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_c_ic((GPS_Ephemeris< double > const *)arg1);
  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.



12460
12461
12462
12463
12464
12465
12466
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
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12460

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;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_c_ic(arg1,(double const &)*arg2);
  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.



12655
12656
12657
12658
12659
12660
12661
12662
12663
12664
12665
12666
12667
12668
12669
12670
12671
12672
12673
12674
12675
12676
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12655

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_c_is((GPS_Ephemeris< double > const *)arg1);
  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.



12612
12613
12614
12615
12616
12617
12618
12619
12620
12621
12622
12623
12624
12625
12626
12627
12628
12629
12630
12631
12632
12633
12634
12635
12636
12637
12638
12639
12640
12641
12642
12643
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12612

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;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_c_is(arg1,(double const &)*arg2);
  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.



12807
12808
12809
12810
12811
12812
12813
12814
12815
12816
12817
12818
12819
12820
12821
12822
12823
12824
12825
12826
12827
12828
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12807

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_c_rc((GPS_Ephemeris< double > const *)arg1);
  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.



12764
12765
12766
12767
12768
12769
12770
12771
12772
12773
12774
12775
12776
12777
12778
12779
12780
12781
12782
12783
12784
12785
12786
12787
12788
12789
12790
12791
12792
12793
12794
12795
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12764

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;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_c_rc(arg1,(double const &)*arg2);
  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.



11767
11768
11769
11770
11771
11772
11773
11774
11775
11776
11777
11778
11779
11780
11781
11782
11783
11784
11785
11786
11787
11788
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11767

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_c_rs((GPS_Ephemeris< double > const *)arg1);
  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.



11724
11725
11726
11727
11728
11729
11730
11731
11732
11733
11734
11735
11736
11737
11738
11739
11740
11741
11742
11743
11744
11745
11746
11747
11748
11749
11750
11751
11752
11753
11754
11755
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11724

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;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_c_rs(arg1,(double const &)*arg2);
  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.



11995
11996
11997
11998
11999
12000
12001
12002
12003
12004
12005
12006
12007
12008
12009
12010
12011
12012
12013
12014
12015
12016
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11995

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_c_uc((GPS_Ephemeris< double > const *)arg1);
  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.



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

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;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_c_uc(arg1,(double const &)*arg2);
  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.



12147
12148
12149
12150
12151
12152
12153
12154
12155
12156
12157
12158
12159
12160
12161
12162
12163
12164
12165
12166
12167
12168
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12147

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_c_us((GPS_Ephemeris< double > const *)arg1);
  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.



12104
12105
12106
12107
12108
12109
12110
12111
12112
12113
12114
12115
12116
12117
12118
12119
12120
12121
12122
12123
12124
12125
12126
12127
12128
12129
12130
12131
12132
12133
12134
12135
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12104

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;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_c_us(arg1,(double const &)*arg2);
  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) 


10527
10528
10529
10530
10531
10532
10533
10534
10535
10536
10537
10538
10539
10540
10541
10542
10543
10544
10545
10546
10547
10548
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10527

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);
  result = (bool)((GPS_Ephemeris< double > const *)arg1)->is_consistent();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#constellation(*args, self) ⇒ Object

call-seq:

constellation(Time t_tx, double const & dt_transit=0) -> GPS_Ephemeris< double >::constellation_res_t
constellation(Time t_tx) -> GPS_Ephemeris< double >::constellation_res_t

An instance method.



13516
13517
13518
13519
13520
13521
13522
13523
13524
13525
13526
13527
13528
13529
13530
13531
13532
13533
13534
13535
13536
13537
13538
13539
13540
13541
13542
13543
13544
13545
13546
13547
13548
13549
13550
13551
13552
13553
13554
13555
13556
13557
13558
13559
13560
13561
13562
13563
13564
13565
13566
13567
13568
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13516

SWIGINTERN VALUE _wrap_Ephemeris_constellation(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_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_1(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_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "constellation", 
    "    GPS_Ephemeris< double >::constellation_res_t constellation(GPS_Time< double > const &t_tx, double const &dt_transit)\n"
    "    GPS_Ephemeris< double >::constellation_res_t constellation(GPS_Time< double > const &t_tx)\n");
  
  return Qnil;
}

#delta_n(*args) ⇒ Object

call-seq:

delta_n -> double const &

An instance method.



11843
11844
11845
11846
11847
11848
11849
11850
11851
11852
11853
11854
11855
11856
11857
11858
11859
11860
11861
11862
11863
11864
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11843

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_delta_n((GPS_Ephemeris< double > const *)arg1);
  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.



11800
11801
11802
11803
11804
11805
11806
11807
11808
11809
11810
11811
11812
11813
11814
11815
11816
11817
11818
11819
11820
11821
11822
11823
11824
11825
11826
11827
11828
11829
11830
11831
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11800

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;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_delta_n(arg1,(double const &)*arg2);
  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.



13035
13036
13037
13038
13039
13040
13041
13042
13043
13044
13045
13046
13047
13048
13049
13050
13051
13052
13053
13054
13055
13056
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13035

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_dot_i0((GPS_Ephemeris< double > const *)arg1);
  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.



12992
12993
12994
12995
12996
12997
12998
12999
13000
13001
13002
13003
13004
13005
13006
13007
13008
13009
13010
13011
13012
13013
13014
13015
13016
13017
13018
13019
13020
13021
13022
13023
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12992

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;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_dot_i0(arg1,(double const &)*arg2);
  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.



12959
12960
12961
12962
12963
12964
12965
12966
12967
12968
12969
12970
12971
12972
12973
12974
12975
12976
12977
12978
12979
12980
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12959

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_dot_Omega0((GPS_Ephemeris< double > const *)arg1);
  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.



12916
12917
12918
12919
12920
12921
12922
12923
12924
12925
12926
12927
12928
12929
12930
12931
12932
12933
12934
12935
12936
12937
12938
12939
12940
12941
12942
12943
12944
12945
12946
12947
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12916

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;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_dot_Omega0(arg1,(double const &)*arg2);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#dump(*args) ⇒ Object

call-seq:

dump(Time t)

An instance method.



13133
13134
13135
13136
13137
13138
13139
13140
13141
13142
13143
13144
13145
13146
13147
13148
13149
13150
13151
13152
13153
13154
13155
13156
13157
13158
13159
13160
13161
13162
13163
13164
13165
13166
13167
13168
13169
13170
13171
13172
13173
13174
13175
13176
13177
13178
13179
13180
13181
13182
13183
13184
13185
13186
13187
13188
13189
13190
13191
13192
13193
13194
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13133

SWIGINTERN VALUE
_wrap_Ephemeris_dump(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  unsigned int *arg2 ;
  unsigned int *arg3 ;
  unsigned int *arg4 ;
  GPS_Time< double > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int temp2[10] = {
    0
  } ;
  unsigned int temp3[10] = {
    0
  } ;
  unsigned int temp4[10] = {
    0
  } ;
  void *argp5 ;
  int res5 = 0 ;
  VALUE vresult = Qnil;
  
  arg2 = temp2;
  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 > *","dump", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  res5 = SWIG_ConvertPtr(argv[0], &argp5, SWIGTYPE_p_GPS_TimeT_double_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "GPS_Time< double > const &","dump", 5, argv[0] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","dump", 5, argv[0])); 
  }
  arg5 = reinterpret_cast< GPS_Time< double > * >(argp5);
  GPS_Ephemeris_Sl_double_Sg__dump(arg1,arg2,arg3,arg4,(GPS_Time< double > const &)*arg5);
  vresult = rb_ary_new();
  {
    for(int i(0); i < 10; ++i){
      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int  ((arg2)[i]));
    }
  }
  {
    for(int i(0); i < 10; ++i){
      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int  ((arg3)[i]));
    }
  }
  {
    for(int i(0); i < 10; ++i){
      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int  ((arg4)[i]));
    }
  }
  return vresult;
fail:
  return Qnil;
}

#dump_almanac(*args, self) ⇒ Object

call-seq:

dump_almanac(Time t, unsigned int const & qzss_subframe=0)
dump_almanac(Time t)

An instance method.



13349
13350
13351
13352
13353
13354
13355
13356
13357
13358
13359
13360
13361
13362
13363
13364
13365
13366
13367
13368
13369
13370
13371
13372
13373
13374
13375
13376
13377
13378
13379
13380
13381
13382
13383
13384
13385
13386
13387
13388
13389
13390
13391
13392
13393
13394
13395
13396
13397
13398
13399
13400
13401
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13349

SWIGINTERN VALUE _wrap_Ephemeris_dump_almanac(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_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_dump_almanac__SWIG_1(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_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Ephemeris_dump_almanac__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "dump_almanac", 
    "    void dump_almanac(unsigned int buf_brdc[10], GPS_Time< double > const &t, unsigned int const &qzss_subframe)\n"
    "    void dump_almanac(unsigned int buf_brdc[10], GPS_Time< double > const &t)\n");
  
  return Qnil;
}

#e(*args) ⇒ Object

call-seq:

e -> double const &

An instance method.



12071
12072
12073
12074
12075
12076
12077
12078
12079
12080
12081
12082
12083
12084
12085
12086
12087
12088
12089
12090
12091
12092
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12071

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_e((GPS_Ephemeris< double > const *)arg1);
  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.



12028
12029
12030
12031
12032
12033
12034
12035
12036
12037
12038
12039
12040
12041
12042
12043
12044
12045
12046
12047
12048
12049
12050
12051
12052
12053
12054
12055
12056
12057
12058
12059
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12028

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;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_e(arg1,(double const &)*arg2);
  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.



12427
12428
12429
12430
12431
12432
12433
12434
12435
12436
12437
12438
12439
12440
12441
12442
12443
12444
12445
12446
12447
12448
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12427

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_fit_interval((GPS_Ephemeris< double > const *)arg1);
  vresult = SWIG_From_double(static_cast< double >(*result));
  return vresult;
fail:
  return Qnil;
}

#fit_interval=(*args, self) ⇒ Object

call-seq:

fit_interval=(bool const & flag) -> double
fit_interval=(double const & v) -> double

An instance method.



12367
12368
12369
12370
12371
12372
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
12404
12405
12406
12407
12408
12409
12410
12411
12412
12413
12414
12415
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12367

SWIGINTERN VALUE _wrap_Ephemeris_fit_intervale___(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) 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) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Ephemeris_fit_intervale_____SWIG_1(nargs, args, self);
      }
    }
  }
  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) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Ephemeris_fit_intervale_____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Ephemeris.fit_interval=", 
    "    double Ephemeris.fit_interval=(bool const &flag)\n"
    "    double Ephemeris.fit_interval=(double const &v)\n");
  
  return Qnil;
}

#i0(*args) ⇒ Object

call-seq:

i0 -> double const &

An instance method.



12731
12732
12733
12734
12735
12736
12737
12738
12739
12740
12741
12742
12743
12744
12745
12746
12747
12748
12749
12750
12751
12752
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12731

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_i0((GPS_Ephemeris< double > const *)arg1);
  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.



12688
12689
12690
12691
12692
12693
12694
12695
12696
12697
12698
12699
12700
12701
12702
12703
12704
12705
12706
12707
12708
12709
12710
12711
12712
12713
12714
12715
12716
12717
12718
12719
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12688

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;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_i0(arg1,(double const &)*arg2);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#invalidate(*args) ⇒ Object

call-seq:

invalidate

An instance method.



10497
10498
10499
10500
10501
10502
10503
10504
10505
10506
10507
10508
10509
10510
10511
10512
10513
10514
10515
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10497

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);
  (arg1)->invalidate();
  return Qnil;
fail:
  return Qnil;
}

#iodc(*args) ⇒ Object

call-seq:

iodc -> int const &

An instance method.



11235
11236
11237
11238
11239
11240
11241
11242
11243
11244
11245
11246
11247
11248
11249
11250
11251
11252
11253
11254
11255
11256
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11235

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);
  result = (int *) &GPS_Ephemeris_Sl_double_Sg__get_iodc((GPS_Ephemeris< double > const *)arg1);
  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.



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

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;
  result = (int)GPS_Ephemeris_Sl_double_Sg__set_iodc(arg1,(int const &)*arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#iode(*args) ⇒ Object

call-seq:

iode -> int const &

An instance method.



11691
11692
11693
11694
11695
11696
11697
11698
11699
11700
11701
11702
11703
11704
11705
11706
11707
11708
11709
11710
11711
11712
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11691

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);
  result = (int *) &GPS_Ephemeris_Sl_double_Sg__get_iode((GPS_Ephemeris< double > const *)arg1);
  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.



11648
11649
11650
11651
11652
11653
11654
11655
11656
11657
11658
11659
11660
11661
11662
11663
11664
11665
11666
11667
11668
11669
11670
11671
11672
11673
11674
11675
11676
11677
11678
11679
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11648

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;
  result = (int)GPS_Ephemeris_Sl_double_Sg__set_iode(arg1,(int const &)*arg2);
  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.



10464
10465
10466
10467
10468
10469
10470
10471
10472
10473
10474
10475
10476
10477
10478
10479
10480
10481
10482
10483
10484
10485
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10464

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.



10435
10436
10437
10438
10439
10440
10441
10442
10443
10444
10445
10446
10447
10448
10449
10450
10451
10452
10453
10454
10455
10456
10457
10458
10459
10460
10461
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10435

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.



11919
11920
11921
11922
11923
11924
11925
11926
11927
11928
11929
11930
11931
11932
11933
11934
11935
11936
11937
11938
11939
11940
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11919

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_M0((GPS_Ephemeris< double > const *)arg1);
  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.



11876
11877
11878
11879
11880
11881
11882
11883
11884
11885
11886
11887
11888
11889
11890
11891
11892
11893
11894
11895
11896
11897
11898
11899
11900
11901
11902
11903
11904
11905
11906
11907
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11876

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;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_M0(arg1,(double const &)*arg2);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#omega(*args) ⇒ Object

call-seq:

omega -> double const &

An instance method.



12883
12884
12885
12886
12887
12888
12889
12890
12891
12892
12893
12894
12895
12896
12897
12898
12899
12900
12901
12902
12903
12904
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12883

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_omega((GPS_Ephemeris< double > const *)arg1);
  vresult = SWIG_From_double(static_cast< double >(*result));
  return vresult;
fail:
  return Qnil;
}

#Omega0(*args) ⇒ Object

call-seq:

Omega0 -> double const &

An instance method.



12579
12580
12581
12582
12583
12584
12585
12586
12587
12588
12589
12590
12591
12592
12593
12594
12595
12596
12597
12598
12599
12600
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12579

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_Omega0((GPS_Ephemeris< double > const *)arg1);
  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.



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

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;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_Omega0(arg1,(double const &)*arg2);
  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.



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 12840

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;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_omega(arg1,(double const &)*arg2);
  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.



13068
13069
13070
13071
13072
13073
13074
13075
13076
13077
13078
13079
13080
13081
13082
13083
13084
13085
13086
13087
13088
13089
13090
13091
13092
13093
13094
13095
13096
13097
13098
13099
13100
13101
13102
13103
13104
13105
13106
13107
13108
13109
13110
13111
13112
13113
13114
13115
13116
13117
13118
13119
13120
13121
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13068

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;
  }
  GPS_Ephemeris_Sl_double_Sg__parse(arg1,(unsigned int const (*))arg2,arg3,arg4);
  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;
}

#parse_almanac(*args) ⇒ Object

call-seq:

parse_almanac(unsigned int const [10] buf) -> int

An instance method.



13206
13207
13208
13209
13210
13211
13212
13213
13214
13215
13216
13217
13218
13219
13220
13221
13222
13223
13224
13225
13226
13227
13228
13229
13230
13231
13232
13233
13234
13235
13236
13237
13238
13239
13240
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13206

SWIGINTERN VALUE
_wrap_Ephemeris_parse_almanac(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  unsigned int *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int temp2[10] ;
  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 > *","parse_almanac", 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;
  }
  result = (int)GPS_Ephemeris_Sl_double_Sg__parse_almanac(arg1,(unsigned int const (*))arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#sqrt_A(*args) ⇒ Object

call-seq:

sqrt_A -> double const &

An instance method.



12223
12224
12225
12226
12227
12228
12229
12230
12231
12232
12233
12234
12235
12236
12237
12238
12239
12240
12241
12242
12243
12244
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12223

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_sqrt_A((GPS_Ephemeris< double > const *)arg1);
  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.



12180
12181
12182
12183
12184
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
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12180

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;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_sqrt_A(arg1,(double const &)*arg2);
  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.



11159
11160
11161
11162
11163
11164
11165
11166
11167
11168
11169
11170
11171
11172
11173
11174
11175
11176
11177
11178
11179
11180
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11159

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);
  result = (unsigned int *) &GPS_Ephemeris_Sl_double_Sg__get_SV_health((GPS_Ephemeris< double > const *)arg1);
  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.



11116
11117
11118
11119
11120
11121
11122
11123
11124
11125
11126
11127
11128
11129
11130
11131
11132
11133
11134
11135
11136
11137
11138
11139
11140
11141
11142
11143
11144
11145
11146
11147
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11116

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;
  result = (unsigned int)GPS_Ephemeris_Sl_double_Sg__set_SV_health(arg1,(unsigned int const &)*arg2);
  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.



10931
10932
10933
10934
10935
10936
10937
10938
10939
10940
10941
10942
10943
10944
10945
10946
10947
10948
10949
10950
10951
10952
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10931

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);
  result = (unsigned int *) &GPS_Ephemeris_Sl_double_Sg__get_svid((GPS_Ephemeris< double > const *)arg1);
  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.



10888
10889
10890
10891
10892
10893
10894
10895
10896
10897
10898
10899
10900
10901
10902
10903
10904
10905
10906
10907
10908
10909
10910
10911
10912
10913
10914
10915
10916
10917
10918
10919
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10888

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;
  result = (unsigned int)GPS_Ephemeris_Sl_double_Sg__set_svid(arg1,(unsigned int const &)*arg2);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

#t_clock(*args) ⇒ Object

call-seq:

t_clock -> Time

An instance method.



10604
10605
10606
10607
10608
10609
10610
10611
10612
10613
10614
10615
10616
10617
10618
10619
10620
10621
10622
10623
10624
10625
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10604

SWIGINTERN VALUE
_wrap_Ephemeris_t_clock(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GPS_Time< double > 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 *","t_clock", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  result = ((GPS_Ephemeris< double > const *)arg1)->t_clock();
  vresult = SWIG_NewPointerObj((new GPS_Time< double >(static_cast< const GPS_Time< double >& >(result))), SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#t_ephemeris(*args) ⇒ Object

call-seq:

t_ephemeris -> Time

An instance method.



10637
10638
10639
10640
10641
10642
10643
10644
10645
10646
10647
10648
10649
10650
10651
10652
10653
10654
10655
10656
10657
10658
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10637

SWIGINTERN VALUE
_wrap_Ephemeris_t_ephemeris(int argc, VALUE *argv, VALUE self) {
  GPS_Ephemeris< double > *arg1 = (GPS_Ephemeris< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GPS_Time< double > 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 *","t_ephemeris", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  result = ((GPS_Ephemeris< double > const *)arg1)->t_ephemeris();
  vresult = SWIG_NewPointerObj((new GPS_Time< double >(static_cast< const GPS_Time< double >& >(result))), SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#t_GD(*args) ⇒ Object

call-seq:

t_GD -> double const &

An instance method.



11311
11312
11313
11314
11315
11316
11317
11318
11319
11320
11321
11322
11323
11324
11325
11326
11327
11328
11329
11330
11331
11332
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11311

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_t_GD((GPS_Ephemeris< double > const *)arg1);
  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.



11268
11269
11270
11271
11272
11273
11274
11275
11276
11277
11278
11279
11280
11281
11282
11283
11284
11285
11286
11287
11288
11289
11290
11291
11292
11293
11294
11295
11296
11297
11298
11299
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11268

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;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_t_GD(arg1,(double const &)*arg2);
  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.



11387
11388
11389
11390
11391
11392
11393
11394
11395
11396
11397
11398
11399
11400
11401
11402
11403
11404
11405
11406
11407
11408
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11387

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_t_oc((GPS_Ephemeris< double > const *)arg1);
  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.



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
11370
11371
11372
11373
11374
11375
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11344

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;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_t_oc(arg1,(double const &)*arg2);
  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.



12299
12300
12301
12302
12303
12304
12305
12306
12307
12308
12309
12310
12311
12312
12313
12314
12315
12316
12317
12318
12319
12320
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12299

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);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_t_oe((GPS_Ephemeris< double > const *)arg1);
  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.



12256
12257
12258
12259
12260
12261
12262
12263
12264
12265
12266
12267
12268
12269
12270
12271
12272
12273
12274
12275
12276
12277
12278
12279
12280
12281
12282
12283
12284
12285
12286
12287
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12256

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;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_t_oe(arg1,(double const &)*arg2);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#URA(*args) ⇒ Object

call-seq:

URA -> double const &

An instance method.



11083
11084
11085
11086
11087
11088
11089
11090
11091
11092
11093
11094
11095
11096
11097
11098
11099
11100
11101
11102
11103
11104
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11083

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 ;
  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_URA", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  result = (double *) &GPS_Ephemeris_Sl_double_Sg__get_URA((GPS_Ephemeris< double > const *)arg1);
  vresult = SWIG_From_double(static_cast< double >(*result));
  return vresult;
fail:
  return Qnil;
}

#URA=(*args) ⇒ Object

call-seq:

URA=(double const & v) -> double

An instance method.



11040
11041
11042
11043
11044
11045
11046
11047
11048
11049
11050
11051
11052
11053
11054
11055
11056
11057
11058
11059
11060
11061
11062
11063
11064
11065
11066
11067
11068
11069
11070
11071
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11040

SWIGINTERN VALUE
_wrap_Ephemeris_URAe___(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_URA", 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_URA", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  result = (double)GPS_Ephemeris_Sl_double_Sg__set_URA(arg1,(double const &)*arg2);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#URA_index(*args) ⇒ Object

call-seq:

URA_index -> int

An instance method.



10768
10769
10770
10771
10772
10773
10774
10775
10776
10777
10778
10779
10780
10781
10782
10783
10784
10785
10786
10787
10788
10789
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10768

SWIGINTERN VALUE
_wrap_Ephemeris_URA_index(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 > const *","get_URA_index", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ephemeris< double > * >(argp1);
  result = (int)((GPS_Ephemeris< double > const *)arg1)->get_URA_index();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#URA_index=(*args) ⇒ Object

call-seq:

URA_index=(int const & idx) -> int

An instance method.



10801
10802
10803
10804
10805
10806
10807
10808
10809
10810
10811
10812
10813
10814
10815
10816
10817
10818
10819
10820
10821
10822
10823
10824
10825
10826
10827
10828
10829
10830
10831
10832
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10801

SWIGINTERN VALUE
_wrap_Ephemeris_URA_indexe___(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_index", 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_index", 2, argv[0] ));
  } 
  temp2 = static_cast< int >(val2);
  arg2 = &temp2;
  result = (int)(arg1)->set_URA_index((int const &)*arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#valid?(*args) ⇒ Boolean

call-seq:

valid?(Time t) -> bool

An instance method.

Returns:

  • (Boolean) 


10560
10561
10562
10563
10564
10565
10566
10567
10568
10569
10570
10571
10572
10573
10574
10575
10576
10577
10578
10579
10580
10581
10582
10583
10584
10585
10586
10587
10588
10589
10590
10591
10592
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 10560

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

#WN(*args) ⇒ Object

call-seq:

WN -> unsigned int const &

An instance method.



11007
11008
11009
11010
11011
11012
11013
11014
11015
11016
11017
11018
11019
11020
11021
11022
11023
11024
11025
11026
11027
11028
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 11007

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);
  result = (unsigned int *) &GPS_Ephemeris_Sl_double_Sg__get_WN((GPS_Ephemeris< double > const *)arg1);
  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.



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

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;
  result = (unsigned int)GPS_Ephemeris_Sl_double_Sg__set_WN(arg1,(unsigned int const &)*arg2);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}