Class: GPS_PVT::GPS::Ionospheric_UTC_Parameters

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

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object

call-seq:

Ionospheric_UTC_Parameters.new

Class constructor.



9561
9562
9563
9564
9565
9566
9567
9568
9569
9570
9571
9572
9573
9574
9575
9576
9577
9578
9579
9580
9581
9582
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9561

SWIGINTERN VALUE
_wrap_new_Ionospheric_UTC_Parameters(int argc, VALUE *argv, VALUE self) {
  GPS_Ionospheric_UTC_Parameters< double > *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (GPS_Ionospheric_UTC_Parameters< double > *)new GPS_Ionospheric_UTC_Parameters< double >();
      DATA_PTR(self) = result;
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}

Class Method Details

.parse(*args) ⇒ Object

call-seq:

parse(unsigned int const [10] buf) -> Ionospheric_UTC_Parameters

A class method.



9499
9500
9501
9502
9503
9504
9505
9506
9507
9508
9509
9510
9511
9512
9513
9514
9515
9516
9517
9518
9519
9520
9521
9522
9523
9524
9525
9526
9527
9528
9529
9530
9531
9532
9533
9534
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9499

SWIGINTERN VALUE
_wrap_Ionospheric_UTC_Parameters_parse(int argc, VALUE *argv, VALUE self) {
  unsigned int *arg1 ;
  unsigned int temp1[10] ;
  GPS_Ionospheric_UTC_Parameters< double > result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    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), &temp1[i]))){
        SWIG_exception(SWIG_TypeError, "unsigned int is expected");
      }
    }
    arg1 = temp1;
  }
  {
    try {
      result = GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__parse((unsigned int const (*))arg1);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_NewPointerObj((new GPS_Ionospheric_UTC_Parameters< double >(static_cast< const GPS_Ionospheric_UTC_Parameters< double >& >(result))), SWIGTYPE_p_GPS_Ionospheric_UTC_ParametersT_double_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

Instance Method Details

#A0(*args) ⇒ Object

call-seq:

A0 -> double const &

An instance method.



8893
8894
8895
8896
8897
8898
8899
8900
8901
8902
8903
8904
8905
8906
8907
8908
8909
8910
8911
8912
8913
8914
8915
8916
8917
8918
8919
8920
8921
8922
8923
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8893

SWIGINTERN VALUE
_wrap_Ionospheric_UTC_Parameters_A0(int argc, VALUE *argv, VALUE self) {
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< 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_Ionospheric_UTC_ParametersT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > const *","get_A0", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__get_A0((GPS_Ionospheric_UTC_Parameters< double > const *)arg1);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_double(static_cast< double >(*result));
  return vresult;
fail:
  return Qnil;
}

#A0=(*args) ⇒ Object

call-seq:

A0=(double const & v) -> double

An instance method.



8841
8842
8843
8844
8845
8846
8847
8848
8849
8850
8851
8852
8853
8854
8855
8856
8857
8858
8859
8860
8861
8862
8863
8864
8865
8866
8867
8868
8869
8870
8871
8872
8873
8874
8875
8876
8877
8878
8879
8880
8881
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8841

SWIGINTERN VALUE
_wrap_Ionospheric_UTC_Parameters_A0e___(int argc, VALUE *argv, VALUE self) {
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< 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_Ionospheric_UTC_ParametersT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > *","set_A0", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_A0", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__set_A0(arg1,(double const &)*arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#A1(*args) ⇒ Object

call-seq:

A1 -> double const &

An instance method.



8799
8800
8801
8802
8803
8804
8805
8806
8807
8808
8809
8810
8811
8812
8813
8814
8815
8816
8817
8818
8819
8820
8821
8822
8823
8824
8825
8826
8827
8828
8829
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8799

SWIGINTERN VALUE
_wrap_Ionospheric_UTC_Parameters_A1(int argc, VALUE *argv, VALUE self) {
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< 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_Ionospheric_UTC_ParametersT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > const *","get_A1", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< double > * >(argp1);
  {
    try {
      result = (double *) &GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__get_A1((GPS_Ionospheric_UTC_Parameters< double > const *)arg1);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_double(static_cast< double >(*result));
  return vresult;
fail:
  return Qnil;
}

#A1=(*args) ⇒ Object

call-seq:

A1=(double const & v) -> double

An instance method.



8747
8748
8749
8750
8751
8752
8753
8754
8755
8756
8757
8758
8759
8760
8761
8762
8763
8764
8765
8766
8767
8768
8769
8770
8771
8772
8773
8774
8775
8776
8777
8778
8779
8780
8781
8782
8783
8784
8785
8786
8787
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8747

SWIGINTERN VALUE
_wrap_Ionospheric_UTC_Parameters_A1e___(int argc, VALUE *argv, VALUE self) {
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< 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_Ionospheric_UTC_ParametersT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > *","set_A1", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_A1", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (double)GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__set_A1(arg1,(double const &)*arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#alpha(*args) ⇒ Object

call-seq:

alpha

An instance method.



8589
8590
8591
8592
8593
8594
8595
8596
8597
8598
8599
8600
8601
8602
8603
8604
8605
8606
8607
8608
8609
8610
8611
8612
8613
8614
8615
8616
8617
8618
8619
8620
8621
8622
8623
8624
8625
8626
8627
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8589

SWIGINTERN VALUE
_wrap_Ionospheric_UTC_Parameters_alpha(int argc, VALUE *argv, VALUE self) {
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< double > *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2[4] ;
  VALUE vresult = Qnil;
  
  
  arg2 = temp2;
  
  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_Ionospheric_UTC_ParametersT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > const *","get_alpha", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< double > * >(argp1);
  {
    try {
      GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__get_alpha((GPS_Ionospheric_UTC_Parameters< double > const *)arg1,arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  {
    for(int i(0); i < 4; ++i){
      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from(arg2[i]));
    }
  }
  return vresult;
fail:
  return Qnil;
}

#alpha=(*args) ⇒ Object

call-seq:

alpha=(double const [4] values)

An instance method.



8531
8532
8533
8534
8535
8536
8537
8538
8539
8540
8541
8542
8543
8544
8545
8546
8547
8548
8549
8550
8551
8552
8553
8554
8555
8556
8557
8558
8559
8560
8561
8562
8563
8564
8565
8566
8567
8568
8569
8570
8571
8572
8573
8574
8575
8576
8577
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8531

SWIGINTERN VALUE
_wrap_Ionospheric_UTC_Parameters_alphae___(int argc, VALUE *argv, VALUE self) {
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< double > *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2[4] ;
  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_Ionospheric_UTC_ParametersT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > *","set_alpha", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< double > * >(argp1);
  {
    if(!(RB_TYPE_P(argv[0], T_ARRAY) && (RARRAY_LEN(argv[0]) == 4))){
      SWIG_exception(SWIG_TypeError, "array[4] is expected");
    }
    for(int i(0); i < 4; ++i){
      if(!SWIG_IsOK(swig::asval(RARRAY_AREF(argv[0], i), &temp2[i]))){
        SWIG_exception(SWIG_TypeError, "double is expected");
      }
    }
    arg2 = temp2;
  }
  {
    try {
      GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__set_alpha(arg1,(double const (*))arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  {
    for(int i(0); i < 4; ++i){
      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from(arg2[i]));
    }
  }
  return vresult;
fail:
  return Qnil;
}

#beta(*args) ⇒ Object

call-seq:

beta

An instance method.



8697
8698
8699
8700
8701
8702
8703
8704
8705
8706
8707
8708
8709
8710
8711
8712
8713
8714
8715
8716
8717
8718
8719
8720
8721
8722
8723
8724
8725
8726
8727
8728
8729
8730
8731
8732
8733
8734
8735
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8697

SWIGINTERN VALUE
_wrap_Ionospheric_UTC_Parameters_beta(int argc, VALUE *argv, VALUE self) {
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< double > *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2[4] ;
  VALUE vresult = Qnil;
  
  
  arg2 = temp2;
  
  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_Ionospheric_UTC_ParametersT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > const *","get_beta", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< double > * >(argp1);
  {
    try {
      GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__get_beta((GPS_Ionospheric_UTC_Parameters< double > const *)arg1,arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  {
    for(int i(0); i < 4; ++i){
      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from(arg2[i]));
    }
  }
  return vresult;
fail:
  return Qnil;
}

#beta=(*args) ⇒ Object

call-seq:

beta=(double const [4] values)

An instance method.



8639
8640
8641
8642
8643
8644
8645
8646
8647
8648
8649
8650
8651
8652
8653
8654
8655
8656
8657
8658
8659
8660
8661
8662
8663
8664
8665
8666
8667
8668
8669
8670
8671
8672
8673
8674
8675
8676
8677
8678
8679
8680
8681
8682
8683
8684
8685
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8639

SWIGINTERN VALUE
_wrap_Ionospheric_UTC_Parameters_betae___(int argc, VALUE *argv, VALUE self) {
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< double > *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2[4] ;
  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_Ionospheric_UTC_ParametersT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > *","set_beta", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< double > * >(argp1);
  {
    if(!(RB_TYPE_P(argv[0], T_ARRAY) && (RARRAY_LEN(argv[0]) == 4))){
      SWIG_exception(SWIG_TypeError, "array[4] is expected");
    }
    for(int i(0); i < 4; ++i){
      if(!SWIG_IsOK(swig::asval(RARRAY_AREF(argv[0], i), &temp2[i]))){
        SWIG_exception(SWIG_TypeError, "double is expected");
      }
    }
    arg2 = temp2;
  }
  {
    try {
      GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__set_beta(arg1,(double const (*))arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  {
    for(int i(0); i < 4; ++i){
      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from(arg2[i]));
    }
  }
  return vresult;
fail:
  return Qnil;
}

#delta_t_LS(*args) ⇒ Object

call-seq:

delta_t_LS -> int const &

An instance method.



9175
9176
9177
9178
9179
9180
9181
9182
9183
9184
9185
9186
9187
9188
9189
9190
9191
9192
9193
9194
9195
9196
9197
9198
9199
9200
9201
9202
9203
9204
9205
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9175

SWIGINTERN VALUE
_wrap_Ionospheric_UTC_Parameters_delta_t_LS(int argc, VALUE *argv, VALUE self) {
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< 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_Ionospheric_UTC_ParametersT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > const *","get_delta_t_LS", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< double > * >(argp1);
  {
    try {
      result = (int *) &GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__get_delta_t_LS((GPS_Ionospheric_UTC_Parameters< double > const *)arg1);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(*result));
  return vresult;
fail:
  return Qnil;
}

#delta_t_LS=(*args) ⇒ Object

call-seq:

delta_t_LS=(int const & v) -> int

An instance method.



9123
9124
9125
9126
9127
9128
9129
9130
9131
9132
9133
9134
9135
9136
9137
9138
9139
9140
9141
9142
9143
9144
9145
9146
9147
9148
9149
9150
9151
9152
9153
9154
9155
9156
9157
9158
9159
9160
9161
9162
9163
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9123

SWIGINTERN VALUE
_wrap_Ionospheric_UTC_Parameters_delta_t_LSe___(int argc, VALUE *argv, VALUE self) {
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< 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_Ionospheric_UTC_ParametersT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > *","set_delta_t_LS", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","set_delta_t_LS", 2, argv[0] ));
  } 
  temp2 = static_cast< int >(val2);
  arg2 = &temp2;
  {
    try {
      result = (int)GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__set_delta_t_LS(arg1,(int const &)*arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#delta_t_LSF(*args) ⇒ Object

call-seq:

delta_t_LSF -> int const &

An instance method.



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

SWIGINTERN VALUE
_wrap_Ionospheric_UTC_Parameters_delta_t_LSF(int argc, VALUE *argv, VALUE self) {
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< 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_Ionospheric_UTC_ParametersT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > const *","get_delta_t_LSF", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< double > * >(argp1);
  {
    try {
      result = (int *) &GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__get_delta_t_LSF((GPS_Ionospheric_UTC_Parameters< double > const *)arg1);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(*result));
  return vresult;
fail:
  return Qnil;
}

#delta_t_LSF=(*args) ⇒ Object

call-seq:

delta_t_LSF=(int const & v) -> int

An instance method.



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

SWIGINTERN VALUE
_wrap_Ionospheric_UTC_Parameters_delta_t_LSFe___(int argc, VALUE *argv, VALUE self) {
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< 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_Ionospheric_UTC_ParametersT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > *","set_delta_t_LSF", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","set_delta_t_LSF", 2, argv[0] ));
  } 
  temp2 = static_cast< int >(val2);
  arg2 = &temp2;
  {
    try {
      result = (int)GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__set_delta_t_LSF(arg1,(int const &)*arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#DN(*args) ⇒ Object

call-seq:

DN -> unsigned int const &

An instance method.



9363
9364
9365
9366
9367
9368
9369
9370
9371
9372
9373
9374
9375
9376
9377
9378
9379
9380
9381
9382
9383
9384
9385
9386
9387
9388
9389
9390
9391
9392
9393
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9363

SWIGINTERN VALUE
_wrap_Ionospheric_UTC_Parameters_DN(int argc, VALUE *argv, VALUE self) {
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< 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_Ionospheric_UTC_ParametersT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > const *","get_DN", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< double > * >(argp1);
  {
    try {
      result = (unsigned int *) &GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__get_DN((GPS_Ionospheric_UTC_Parameters< double > const *)arg1);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(*result));
  return vresult;
fail:
  return Qnil;
}

#DN=(*args) ⇒ Object

call-seq:

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

An instance method.



9311
9312
9313
9314
9315
9316
9317
9318
9319
9320
9321
9322
9323
9324
9325
9326
9327
9328
9329
9330
9331
9332
9333
9334
9335
9336
9337
9338
9339
9340
9341
9342
9343
9344
9345
9346
9347
9348
9349
9350
9351
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9311

SWIGINTERN VALUE
_wrap_Ionospheric_UTC_Parameters_DNe___(int argc, VALUE *argv, VALUE self) {
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< 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_Ionospheric_UTC_ParametersT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > *","set_DN", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< 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_DN", 2, argv[0] ));
  } 
  temp2 = static_cast< unsigned int >(val2);
  arg2 = &temp2;
  {
    try {
      result = (unsigned int)GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__set_DN(arg1,(unsigned int const &)*arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

#t_ot(*args) ⇒ Object

call-seq:

t_ot -> unsigned int const &

An instance method.



8987
8988
8989
8990
8991
8992
8993
8994
8995
8996
8997
8998
8999
9000
9001
9002
9003
9004
9005
9006
9007
9008
9009
9010
9011
9012
9013
9014
9015
9016
9017
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8987

SWIGINTERN VALUE
_wrap_Ionospheric_UTC_Parameters_t_ot(int argc, VALUE *argv, VALUE self) {
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< 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_Ionospheric_UTC_ParametersT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > const *","get_t_ot", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< double > * >(argp1);
  {
    try {
      result = (unsigned int *) &GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__get_t_ot((GPS_Ionospheric_UTC_Parameters< double > const *)arg1);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(*result));
  return vresult;
fail:
  return Qnil;
}

#t_ot=(*args) ⇒ Object

call-seq:

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

An instance method.



8935
8936
8937
8938
8939
8940
8941
8942
8943
8944
8945
8946
8947
8948
8949
8950
8951
8952
8953
8954
8955
8956
8957
8958
8959
8960
8961
8962
8963
8964
8965
8966
8967
8968
8969
8970
8971
8972
8973
8974
8975
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 8935

SWIGINTERN VALUE
_wrap_Ionospheric_UTC_Parameters_t_ote___(int argc, VALUE *argv, VALUE self) {
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< 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_Ionospheric_UTC_ParametersT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > *","set_t_ot", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< 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_t_ot", 2, argv[0] ));
  } 
  temp2 = static_cast< unsigned int >(val2);
  arg2 = &temp2;
  {
    try {
      result = (unsigned int)GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__set_t_ot(arg1,(unsigned int const &)*arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

#WN_LSF(*args) ⇒ Object

call-seq:

WN_LSF -> unsigned int const &

An instance method.



9269
9270
9271
9272
9273
9274
9275
9276
9277
9278
9279
9280
9281
9282
9283
9284
9285
9286
9287
9288
9289
9290
9291
9292
9293
9294
9295
9296
9297
9298
9299
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9269

SWIGINTERN VALUE
_wrap_Ionospheric_UTC_Parameters_WN_LSF(int argc, VALUE *argv, VALUE self) {
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< 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_Ionospheric_UTC_ParametersT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > const *","get_WN_LSF", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< double > * >(argp1);
  {
    try {
      result = (unsigned int *) &GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__get_WN_LSF((GPS_Ionospheric_UTC_Parameters< double > const *)arg1);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(*result));
  return vresult;
fail:
  return Qnil;
}

#WN_LSF=(*args) ⇒ Object

call-seq:

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

An instance method.



9217
9218
9219
9220
9221
9222
9223
9224
9225
9226
9227
9228
9229
9230
9231
9232
9233
9234
9235
9236
9237
9238
9239
9240
9241
9242
9243
9244
9245
9246
9247
9248
9249
9250
9251
9252
9253
9254
9255
9256
9257
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9217

SWIGINTERN VALUE
_wrap_Ionospheric_UTC_Parameters_WN_LSFe___(int argc, VALUE *argv, VALUE self) {
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< 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_Ionospheric_UTC_ParametersT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > *","set_WN_LSF", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< 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_LSF", 2, argv[0] ));
  } 
  temp2 = static_cast< unsigned int >(val2);
  arg2 = &temp2;
  {
    try {
      result = (unsigned int)GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__set_WN_LSF(arg1,(unsigned int const &)*arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

#WN_t(*args) ⇒ Object

call-seq:

WN_t -> unsigned int const &

An instance method.



9081
9082
9083
9084
9085
9086
9087
9088
9089
9090
9091
9092
9093
9094
9095
9096
9097
9098
9099
9100
9101
9102
9103
9104
9105
9106
9107
9108
9109
9110
9111
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9081

SWIGINTERN VALUE
_wrap_Ionospheric_UTC_Parameters_WN_t(int argc, VALUE *argv, VALUE self) {
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< 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_Ionospheric_UTC_ParametersT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > const *","get_WN_t", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< double > * >(argp1);
  {
    try {
      result = (unsigned int *) &GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__get_WN_t((GPS_Ionospheric_UTC_Parameters< double > const *)arg1);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(*result));
  return vresult;
fail:
  return Qnil;
}

#WN_t=(*args) ⇒ Object

call-seq:

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

An instance method.



9029
9030
9031
9032
9033
9034
9035
9036
9037
9038
9039
9040
9041
9042
9043
9044
9045
9046
9047
9048
9049
9050
9051
9052
9053
9054
9055
9056
9057
9058
9059
9060
9061
9062
9063
9064
9065
9066
9067
9068
9069
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 9029

SWIGINTERN VALUE
_wrap_Ionospheric_UTC_Parameters_WN_te___(int argc, VALUE *argv, VALUE self) {
  GPS_Ionospheric_UTC_Parameters< double > *arg1 = (GPS_Ionospheric_UTC_Parameters< 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_Ionospheric_UTC_ParametersT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Ionospheric_UTC_Parameters< double > *","set_WN_t", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_Ionospheric_UTC_Parameters< 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_t", 2, argv[0] ));
  } 
  temp2 = static_cast< unsigned int >(val2);
  arg2 = &temp2;
  {
    try {
      result = (unsigned int)GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__set_WN_t(arg1,(unsigned int const &)*arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}