Class: GPS_PVT::GPS::Time

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

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(*args, self) ⇒ Object 



7382
7383
7384
7385
7386
7387
7388
7389
7390
7391
7392
7393
7394
7395
7396
7397
7398
7399
7400
7401
7402
7403
7404
7405
7406
7407
7408
7409
7410
7411
7412
7413
7414
7415
7416
7417
7418
7419
7420
7421
7422
7423
7424
7425
7426
7427
7428
7429
7430
7431
7432
7433
7434
7435
7436
7437
7438
7439
7440
7441
7442
7443
7444
7445
7446
7447
7448
7449
7450
7451
7452
7453
7454
7455
7456
7457
7458
7459
7460
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7382

SWIGINTERN VALUE _wrap_new_Time(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Time__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Time__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      _v = (TYPE(argv[0]) == T_ARRAY) ? 1 : 0;
      
      
      
    }
    if (_v) {
      return _wrap_new_Time__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = (TYPE(argv[0]) == T_ARRAY) ? 1 : 0;
      
      
      
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Time__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Time__SWIG_4(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Time.new", 
    "    Time.new()\n"
    "    Time.new(GPS_Time< double > const &t)\n"
    "    Time.new(std::tm const &t, GPS_Time< double >::float_t const &leap_seconds)\n"
    "    Time.new(std::tm const &t)\n"
    "    Time.new(int const &week_, GPS_Time< double >::float_t const &seconds_, void *dummy)\n");
  
  return Qnil;
}

Class Method Details

.days_of_month ⇒ Object

call-seq:

Time_days_of_month -> int const []

Get value of attribute.



5231
5232
5233
5234
5235
5236
5237
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 5231

SWIGINTERN VALUE
_wrap_Time_days_of_month_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(GPS_Time< double >::days_of_month), SWIGTYPE_p_int,  0 );
  return _val;
}

.guess_leap_seconds(*args, self) ⇒ Object

call-seq:

guess_leap_seconds(std::tm const & t) -> int
guess_leap_seconds(Time uncorrected) -> int

A class method.



6623
6624
6625
6626
6627
6628
6629
6630
6631
6632
6633
6634
6635
6636
6637
6638
6639
6640
6641
6642
6643
6644
6645
6646
6647
6648
6649
6650
6651
6652
6653
6654
6655
6656
6657
6658
6659
6660
6661
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6623

SWIGINTERN VALUE _wrap_Time_guess_leap_seconds(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 == 1) {
    int _v;
    {
      _v = (TYPE(argv[0]) == T_ARRAY) ? 1 : 0;
      
      
      
    }
    if (_v) {
      return _wrap_Time_guess_leap_seconds__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Time_guess_leap_seconds__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Time.guess_leap_seconds", 
    "    int Time.guess_leap_seconds(std::tm const &t)\n"
    "    int Time.guess_leap_seconds(GPS_Time< GPS_Time< double >::float_t > const &uncorrected)\n");
  
  return Qnil;
}

.is_leap_year(*args) ⇒ Object

call-seq:

is_leap_year(int const & year) -> bool

A class method.



5249
5250
5251
5252
5253
5254
5255
5256
5257
5258
5259
5260
5261
5262
5263
5264
5265
5266
5267
5268
5269
5270
5271
5272
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 5249

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

.leap_second_events ⇒ Object

call-seq:

Time_leap_second_events -> GPS_Time< double >::leap_second_event_t const []

Get value of attribute.



6543
6544
6545
6546
6547
6548
6549
6550
6551
6552
6553
6554
6555
6556
6557
6558
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6543

SWIGINTERN VALUE
_wrap_Time_leap_second_events_get(VALUE self) {
  VALUE _val;
  
  {
    _val = rb_ary_new2(sizeof(GPS_Time< double >::leap_second_events) / sizeof(GPS_Time< double >::leap_second_events[0]));
    for(std::size_t i(0); i < sizeof(GPS_Time< double >::leap_second_events) / sizeof(GPS_Time< double >::leap_second_events[0]); ++i){
      rb_ary_push(_val,
        rb_ary_new3(3,
          SWIG_From_int  (GPS_Time< double >::leap_second_events[i].corrected.week),
          swig::from(GPS_Time< double >::leap_second_events[i].corrected.seconds),
          SWIG_From_int  (GPS_Time< double >::leap_second_events[i].leap_seconds)));
    }
  }
  return _val;
}

.leap_year_prop(*args, self) ⇒ Object

call-seq:

leap_year_prop(int const & this_year, bool const & skip_init_leap_year_check=False) -> GPS_Time< double >::leap_year_prop_res_t
leap_year_prop(int const & this_year) -> GPS_Time< double >::leap_year_prop_res_t

A class method.



5347
5348
5349
5350
5351
5352
5353
5354
5355
5356
5357
5358
5359
5360
5361
5362
5363
5364
5365
5366
5367
5368
5369
5370
5371
5372
5373
5374
5375
5376
5377
5378
5379
5380
5381
5382
5383
5384
5385
5386
5387
5388
5389
5390
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 5347

SWIGINTERN VALUE _wrap_Time_leap_year_prop(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_Time_leap_year_prop__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Time_leap_year_prop__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Time.leap_year_prop", 
    "    GPS_Time< double >::leap_year_prop_res_t Time.leap_year_prop(int const &this_year, bool const &skip_init_leap_year_check)\n"
    "    GPS_Time< double >::leap_year_prop_res_t Time.leap_year_prop(int const &this_year)\n");
  
  return Qnil;
}

.now(*args, self) ⇒ Object

call-seq:

now(GPS_Time< double >::float_t const & leap_seconds=0) -> Time
now -> Time

A class method.



5699
5700
5701
5702
5703
5704
5705
5706
5707
5708
5709
5710
5711
5712
5713
5714
5715
5716
5717
5718
5719
5720
5721
5722
5723
5724
5725
5726
5727
5728
5729
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 5699

SWIGINTERN VALUE _wrap_Time_now(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_Time_now__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_Time_now__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Time.now", 
    "    GPS_Time< double > Time.now(GPS_Time< double >::float_t const &leap_seconds)\n"
    "    GPS_Time< double > Time.now()\n");
  
  return Qnil;
}

Instance Method Details

#+(*args) ⇒ Object

call-seq:

+(sec) -> Time

Add operator.



5773
5774
5775
5776
5777
5778
5779
5780
5781
5782
5783
5784
5785
5786
5787
5788
5789
5790
5791
5792
5793
5794
5795
5796
5797
5798
5799
5800
5801
5802
5803
5804
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 5773

SWIGINTERN VALUE
_wrap_Time___add__(int argc, VALUE *argv, VALUE self) {
  GPS_Time< double > *arg1 = (GPS_Time< double > *) 0 ;
  GPS_Time< double >::float_t *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GPS_Time< double >::float_t temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  GPS_Time< 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_TimeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Time< double > const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Time< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "GPS_Time< double >::float_t","operator +", 2, argv[0] ));
  } 
  temp2 = static_cast< GPS_Time< double >::float_t >(val2);
  arg2 = &temp2;
  result = ((GPS_Time< double > const *)arg1)->operator +((GPS_Time< double >::float_t const &)*arg2);
  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;
}

#-(*args, self) ⇒ Object

call-seq:

-(sec) -> Time
-(t) -> GPS_Time< double >::float_t

Substraction operator.



5885
5886
5887
5888
5889
5890
5891
5892
5893
5894
5895
5896
5897
5898
5899
5900
5901
5902
5903
5904
5905
5906
5907
5908
5909
5910
5911
5912
5913
5914
5915
5916
5917
5918
5919
5920
5921
5922
5923
5924
5925
5926
5927
5928
5929
5930
5931
5932
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 5885

SWIGINTERN VALUE _wrap_Time___sub__(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_TimeT_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_Time___sub____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_TimeT_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_Time___sub____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Time.__sub__", 
    "    GPS_Time< double > Time.__sub__(GPS_Time< double >::float_t const &sec)\n"
    "    GPS_Time< double >::float_t Time.__sub__(GPS_Time< double > const &t)\n");
  
  return Qnil;
}

#<(*args) ⇒ Object

call-seq:

<(t) -> bool

Lower than comparison operator.



5943
5944
5945
5946
5947
5948
5949
5950
5951
5952
5953
5954
5955
5956
5957
5958
5959
5960
5961
5962
5963
5964
5965
5966
5967
5968
5969
5970
5971
5972
5973
5974
5975
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 5943

SWIGINTERN VALUE
_wrap_Time___lt__(int argc, VALUE *argv, VALUE self) {
  GPS_Time< double > *arg1 = (GPS_Time< 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_TimeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Time< double > const *","operator <", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Time< 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 &","operator <", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","operator <", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
  result = (bool)((GPS_Time< double > const *)arg1)->operator <((GPS_Time< double > const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#<=(*args) ⇒ Object

call-seq:

<=(t) -> bool

Lower or equal comparison operator.



6072
6073
6074
6075
6076
6077
6078
6079
6080
6081
6082
6083
6084
6085
6086
6087
6088
6089
6090
6091
6092
6093
6094
6095
6096
6097
6098
6099
6100
6101
6102
6103
6104
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6072

SWIGINTERN VALUE
_wrap_Time___le__(int argc, VALUE *argv, VALUE self) {
  GPS_Time< double > *arg1 = (GPS_Time< 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_TimeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Time< double > const *","operator <=", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Time< 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 &","operator <=", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","operator <=", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
  result = (bool)((GPS_Time< double > const *)arg1)->operator <=((GPS_Time< double > const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#<=>(*args) ⇒ Object

call-seq:

<=>(t) -> int

Comparison operator. Returns < 0 for less than, 0 for equal or > 1 for higher than..



7522
7523
7524
7525
7526
7527
7528
7529
7530
7531
7532
7533
7534
7535
7536
7537
7538
7539
7540
7541
7542
7543
7544
7545
7546
7547
7548
7549
7550
7551
7552
7553
7554
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7522

SWIGINTERN VALUE
_wrap_Time___cmp__(int argc, VALUE *argv, VALUE self) {
  GPS_Time< double > *arg1 = (GPS_Time< double > *) 0 ;
  GPS_Time< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_TimeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Time< double > const *","__cmp__", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Time< 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 &","__cmp__", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","__cmp__", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
  result = (int)GPS_Time_Sl_double_Sg____cmp__((GPS_Time< double > const *)arg1,(GPS_Time< double > const &)*arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#==(*args) ⇒ Object

call-seq:

==(t) -> bool

Equality comparison operator.



6029
6030
6031
6032
6033
6034
6035
6036
6037
6038
6039
6040
6041
6042
6043
6044
6045
6046
6047
6048
6049
6050
6051
6052
6053
6054
6055
6056
6057
6058
6059
6060
6061
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6029

SWIGINTERN VALUE
_wrap_Time___eq__(int argc, VALUE *argv, VALUE self) {
  GPS_Time< double > *arg1 = (GPS_Time< 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_TimeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Time< double > const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Time< 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 &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
  result = (bool)((GPS_Time< double > const *)arg1)->operator ==((GPS_Time< double > const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#>(*args) ⇒ Object

call-seq:

>(t) -> bool

Higher than comparison operator.



5986
5987
5988
5989
5990
5991
5992
5993
5994
5995
5996
5997
5998
5999
6000
6001
6002
6003
6004
6005
6006
6007
6008
6009
6010
6011
6012
6013
6014
6015
6016
6017
6018
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 5986

SWIGINTERN VALUE
_wrap_Time___gt__(int argc, VALUE *argv, VALUE self) {
  GPS_Time< double > *arg1 = (GPS_Time< 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_TimeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Time< double > const *","operator >", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Time< 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 &","operator >", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","operator >", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
  result = (bool)((GPS_Time< double > const *)arg1)->operator >((GPS_Time< double > const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#>=(*args) ⇒ Object

call-seq:

>=(t) -> bool

Higher or equal comparison operator.



6115
6116
6117
6118
6119
6120
6121
6122
6123
6124
6125
6126
6127
6128
6129
6130
6131
6132
6133
6134
6135
6136
6137
6138
6139
6140
6141
6142
6143
6144
6145
6146
6147
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6115

SWIGINTERN VALUE
_wrap_Time___ge__(int argc, VALUE *argv, VALUE self) {
  GPS_Time< double > *arg1 = (GPS_Time< 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_TimeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Time< double > const *","operator >=", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Time< 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 &","operator >=", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","operator >=", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
  result = (bool)((GPS_Time< double > const *)arg1)->operator >=((GPS_Time< double > const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#c_tm(*args, self) ⇒ Object

call-seq:

c_tm(GPS_Time< double >::float_t const & leap_seconds=0) -> std::tm
c_tm -> std::tm

An instance method.



6222
6223
6224
6225
6226
6227
6228
6229
6230
6231
6232
6233
6234
6235
6236
6237
6238
6239
6240
6241
6242
6243
6244
6245
6246
6247
6248
6249
6250
6251
6252
6253
6254
6255
6256
6257
6258
6259
6260
6261
6262
6263
6264
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6222

SWIGINTERN VALUE _wrap_Time_c_tm(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Time_c_tm__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_TimeT_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_Time_c_tm__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Time.c_tm", 
    "    std::tm Time.c_tm(GPS_Time< double >::float_t const &leap_seconds)\n"
    "    std::tm Time.c_tm()\n");
  
  return Qnil;
}

#earth_rotation_angle(*args, self) ⇒ Object

call-seq:

earth_rotation_angle(GPS_Time< double >::float_t const & delta_ut1=GPS_Time< double >::float_t(0), GPS_Time< double >::float_t const & scale_factor=GPS_Time< double >::float_t(M_PI * 2)) -> GPS_Time< double >::float_t
earth_rotation_angle(GPS_Time< double >::float_t const & delta_ut1=GPS_Time< double >::float_t(0)) -> GPS_Time< double >::float_t
earth_rotation_angle -> GPS_Time< double >::float_t

An instance method.



7024
7025
7026
7027
7028
7029
7030
7031
7032
7033
7034
7035
7036
7037
7038
7039
7040
7041
7042
7043
7044
7045
7046
7047
7048
7049
7050
7051
7052
7053
7054
7055
7056
7057
7058
7059
7060
7061
7062
7063
7064
7065
7066
7067
7068
7069
7070
7071
7072
7073
7074
7075
7076
7077
7078
7079
7080
7081
7082
7083
7084
7085
7086
7087
7088
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7024

SWIGINTERN VALUE _wrap_Time_earth_rotation_angle(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Time_earth_rotation_angle__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_TimeT_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_Time_earth_rotation_angle__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Time_earth_rotation_angle__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Time.earth_rotation_angle", 
    "    GPS_Time< double >::float_t Time.earth_rotation_angle(GPS_Time< double >::float_t const &delta_ut1, GPS_Time< double >::float_t const &scale_factor)\n"
    "    GPS_Time< double >::float_t Time.earth_rotation_angle(GPS_Time< double >::float_t const &delta_ut1)\n"
    "    GPS_Time< double >::float_t Time.earth_rotation_angle()\n");
  
  return Qnil;
}

#greenwich_mean_sidereal_time_sec(*args, self) ⇒ Object

call-seq:

greenwich_mean_sidereal_time_sec(GPS_Time< double >::float_t const & delta_ut1=GPS_Time< double >::float_t(0)) -> GPS_Time< double >::float_t
greenwich_mean_sidereal_time_sec -> GPS_Time< double >::float_t

An instance method.



7272
7273
7274
7275
7276
7277
7278
7279
7280
7281
7282
7283
7284
7285
7286
7287
7288
7289
7290
7291
7292
7293
7294
7295
7296
7297
7298
7299
7300
7301
7302
7303
7304
7305
7306
7307
7308
7309
7310
7311
7312
7313
7314
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7272

SWIGINTERN VALUE _wrap_Time_greenwich_mean_sidereal_time_sec(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Time_greenwich_mean_sidereal_time_sec__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_TimeT_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_Time_greenwich_mean_sidereal_time_sec__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Time.greenwich_mean_sidereal_time_sec", 
    "    GPS_Time< double >::float_t Time.greenwich_mean_sidereal_time_sec(GPS_Time< double >::float_t const &delta_ut1)\n"
    "    GPS_Time< double >::float_t Time.greenwich_mean_sidereal_time_sec()\n");
  
  return Qnil;
}

#greenwich_mean_sidereal_time_sec_ires1996(*args, self) ⇒ Object

call-seq:

greenwich_mean_sidereal_time_sec_ires1996(GPS_Time< double >::float_t const & delta_ut1=GPS_Time< double >::float_t(0)) -> GPS_Time< double >::float_t
greenwich_mean_sidereal_time_sec_ires1996 -> GPS_Time< double >::float_t

An instance method.



6866
6867
6868
6869
6870
6871
6872
6873
6874
6875
6876
6877
6878
6879
6880
6881
6882
6883
6884
6885
6886
6887
6888
6889
6890
6891
6892
6893
6894
6895
6896
6897
6898
6899
6900
6901
6902
6903
6904
6905
6906
6907
6908
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6866

SWIGINTERN VALUE _wrap_Time_greenwich_mean_sidereal_time_sec_ires1996(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Time_greenwich_mean_sidereal_time_sec_ires1996__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_TimeT_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_Time_greenwich_mean_sidereal_time_sec_ires1996__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Time.greenwich_mean_sidereal_time_sec_ires1996", 
    "    GPS_Time< double >::float_t Time.greenwich_mean_sidereal_time_sec_ires1996(GPS_Time< double >::float_t const &delta_ut1)\n"
    "    GPS_Time< double >::float_t Time.greenwich_mean_sidereal_time_sec_ires1996()\n");
  
  return Qnil;
}

#greenwich_mean_sidereal_time_sec_ires2010(*args, self) ⇒ Object

call-seq:

greenwich_mean_sidereal_time_sec_ires2010(GPS_Time< double >::float_t const & delta_ut1=GPS_Time< double >::float_t(0)) -> GPS_Time< double >::float_t
greenwich_mean_sidereal_time_sec_ires2010 -> GPS_Time< double >::float_t

An instance method.



7159
7160
7161
7162
7163
7164
7165
7166
7167
7168
7169
7170
7171
7172
7173
7174
7175
7176
7177
7178
7179
7180
7181
7182
7183
7184
7185
7186
7187
7188
7189
7190
7191
7192
7193
7194
7195
7196
7197
7198
7199
7200
7201
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7159

SWIGINTERN VALUE _wrap_Time_greenwich_mean_sidereal_time_sec_ires2010(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Time_greenwich_mean_sidereal_time_sec_ires2010__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_TimeT_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_Time_greenwich_mean_sidereal_time_sec_ires2010__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Time.greenwich_mean_sidereal_time_sec_ires2010", 
    "    GPS_Time< double >::float_t Time.greenwich_mean_sidereal_time_sec_ires2010(GPS_Time< double >::float_t const &delta_ut1)\n"
    "    GPS_Time< double >::float_t Time.greenwich_mean_sidereal_time_sec_ires2010()\n");
  
  return Qnil;
}

#interval(*args, self) ⇒ Object

call-seq:

interval(unsigned int const & t_week, GPS_Time< double >::float_t const & t_seconds) -> GPS_Time< double >::float_t
interval(Time t) -> GPS_Time< double >::float_t

An instance method.



6469
6470
6471
6472
6473
6474
6475
6476
6477
6478
6479
6480
6481
6482
6483
6484
6485
6486
6487
6488
6489
6490
6491
6492
6493
6494
6495
6496
6497
6498
6499
6500
6501
6502
6503
6504
6505
6506
6507
6508
6509
6510
6511
6512
6513
6514
6515
6516
6517
6518
6519
6520
6521
6522
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6469

SWIGINTERN VALUE _wrap_Time_interval(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_TimeT_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_Time_interval__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Time_interval__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Time.interval", 
    "    GPS_Time< double >::float_t Time.interval(unsigned int const &t_week, GPS_Time< double >::float_t const &t_seconds)\n"
    "    GPS_Time< double >::float_t Time.interval(GPS_Time< double > const &t)\n");
  
  return Qnil;
}

#julian_date(*args) ⇒ Object

call-seq:

julian_date -> GPS_Time< double >::float_t

An instance method.



6706
6707
6708
6709
6710
6711
6712
6713
6714
6715
6716
6717
6718
6719
6720
6721
6722
6723
6724
6725
6726
6727
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6706

SWIGINTERN VALUE
_wrap_Time_julian_date(int argc, VALUE *argv, VALUE self) {
  GPS_Time< double > *arg1 = (GPS_Time< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GPS_Time< double >::float_t 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_TimeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Time< double > const *","julian_date", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Time< double > * >(argp1);
  result = (GPS_Time< double >::float_t)((GPS_Time< double > const *)arg1)->julian_date();
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#julian_date_2000(*args) ⇒ Object

call-seq:

julian_date_2000 -> GPS_Time< double >::float_t

An instance method.



6739
6740
6741
6742
6743
6744
6745
6746
6747
6748
6749
6750
6751
6752
6753
6754
6755
6756
6757
6758
6759
6760
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6739

SWIGINTERN VALUE
_wrap_Time_julian_date_2000(int argc, VALUE *argv, VALUE self) {
  GPS_Time< double > *arg1 = (GPS_Time< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GPS_Time< double >::float_t 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_TimeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Time< double > const *","julian_date_2000", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Time< double > * >(argp1);
  result = (GPS_Time< double >::float_t)((GPS_Time< double > const *)arg1)->julian_date_2000();
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#leap_seconds(*args) ⇒ Object

call-seq:

leap_seconds -> int

An instance method.



6673
6674
6675
6676
6677
6678
6679
6680
6681
6682
6683
6684
6685
6686
6687
6688
6689
6690
6691
6692
6693
6694
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6673

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

#seconds(*args) ⇒ Object

call-seq:

seconds -> GPS_Time< double >::float_t

Get value of attribute.



5511
5512
5513
5514
5515
5516
5517
5518
5519
5520
5521
5522
5523
5524
5525
5526
5527
5528
5529
5530
5531
5532
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 5511

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

#seconds=(*args) ⇒ Object

call-seq:

seconds=(x) -> GPS_Time< double >::float_t

Set new value for attribute.



5482
5483
5484
5485
5486
5487
5488
5489
5490
5491
5492
5493
5494
5495
5496
5497
5498
5499
5500
5501
5502
5503
5504
5505
5506
5507
5508
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 5482

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

#serialize(*args) ⇒ Object

call-seq:

serialize -> GPS_Time< double >::float_t

An instance method.



5741
5742
5743
5744
5745
5746
5747
5748
5749
5750
5751
5752
5753
5754
5755
5756
5757
5758
5759
5760
5761
5762
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 5741

SWIGINTERN VALUE
_wrap_Time_serialize(int argc, VALUE *argv, VALUE self) {
  GPS_Time< double > *arg1 = (GPS_Time< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GPS_Time< double >::float_t 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_TimeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Time< double > const *","serialize", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Time< double > * >(argp1);
  result = (GPS_Time< double >::float_t)((GPS_Time< double > const *)arg1)->serialize();
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#to_a(*args) ⇒ Object

call-seq:

to_a

Convert Time to an Array.



7471
7472
7473
7474
7475
7476
7477
7478
7479
7480
7481
7482
7483
7484
7485
7486
7487
7488
7489
7490
7491
7492
7493
7494
7495
7496
7497
7498
7499
7500
7501
7502
7503
7504
7505
7506
7507
7508
7509
7510
7511
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 7471

SWIGINTERN VALUE
_wrap_Time_to_a(int argc, VALUE *argv, VALUE self) {
  GPS_Time< double > *arg1 = (GPS_Time< double > *) 0 ;
  int *arg2 = (int *) 0 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  double temp3 ;
  int res3 = SWIG_TMPOBJ ;
  VALUE vresult = Qnil;
  
  arg2 = &temp2;
  arg3 = &temp3;
  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_TimeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Time< double > const *","to_a", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Time< double > * >(argp1);
  GPS_Time_Sl_double_Sg__to_a((GPS_Time< double > const *)arg1,arg2,arg3);
  vresult = rb_ary_new();
  if (SWIG_IsTmpObj(res2)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
  }
  if (SWIG_IsTmpObj(res3)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_double((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
  }
  return vresult;
fail:
  return Qnil;
}

#utc(*args) ⇒ Object

call-seq:

utc -> std::tm

An instance method.



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

SWIGINTERN VALUE
_wrap_Time_utc(int argc, VALUE *argv, VALUE self) {
  GPS_Time< double > *arg1 = (GPS_Time< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::tm 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_TimeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Time< double > const *","utc", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Time< double > * >(argp1);
  result = ((GPS_Time< double > const *)arg1)->utc();
  {
    vresult = SWIG_From_std_tm  (result);
  }
  return vresult;
fail:
  return Qnil;
}

#week(*args) ⇒ Object

call-seq:

week -> int

Get value of attribute.



5440
5441
5442
5443
5444
5445
5446
5447
5448
5449
5450
5451
5452
5453
5454
5455
5456
5457
5458
5459
5460
5461
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 5440

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

#week=(*args) ⇒ Object

call-seq:

week=(x) -> int

Set new value for attribute.



5411
5412
5413
5414
5415
5416
5417
5418
5419
5420
5421
5422
5423
5424
5425
5426
5427
5428
5429
5430
5431
5432
5433
5434
5435
5436
5437
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 5411

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

#year(*args, self) ⇒ Object

call-seq:

year(GPS_Time< double >::float_t const & leap_seconds=0) -> GPS_Time< double >::float_t
year -> GPS_Time< double >::float_t

An instance method.



6335
6336
6337
6338
6339
6340
6341
6342
6343
6344
6345
6346
6347
6348
6349
6350
6351
6352
6353
6354
6355
6356
6357
6358
6359
6360
6361
6362
6363
6364
6365
6366
6367
6368
6369
6370
6371
6372
6373
6374
6375
6376
6377
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 6335

SWIGINTERN VALUE _wrap_Time_year(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Time_year__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_TimeT_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_Time_year__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Time.year", 
    "    GPS_Time< double >::float_t Time.year(GPS_Time< double >::float_t const &leap_seconds)\n"
    "    GPS_Time< double >::float_t Time.year()\n");
  
  return Qnil;
}