Class: GPS_PVT::GPS::PVT

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object

call-seq:

PVT.new

Class constructor.



13610
13611
13612
13613
13614
13615
13616
13617
13618
13619
13620
13621
13622
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13610

SWIGINTERN VALUE
_wrap_new_PVT(int argc, VALUE *argv, VALUE self) {
  GPS_User_PVT< double > *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (GPS_User_PVT< double > *)new GPS_User_PVT< double >();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}

Instance Method Details

#C(*args) ⇒ Object

call-seq:

C -> MatrixD

An instance method.



14523
14524
14525
14526
14527
14528
14529
14530
14531
14532
14533
14534
14535
14536
14537
14538
14539
14540
14541
14542
14543
14544
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14523

SWIGINTERN VALUE
_wrap_PVT_C(int argc, VALUE *argv, VALUE self) {
  GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Matrix< double,Array2D_Dense< 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_User_PVTT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","C", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  result = ((GPS_User_PVT< double > const *)arg1)->C();
  vresult = SWIG_NewPointerObj((new Matrix< double,Array2D_Dense< double > >(static_cast< const Matrix< double,Array2D_Dense< double > >& >(result))), SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#C_enu(*args) ⇒ Object

call-seq:

C_enu -> MatrixD

An instance method.



14556
14557
14558
14559
14560
14561
14562
14563
14564
14565
14566
14567
14568
14569
14570
14571
14572
14573
14574
14575
14576
14577
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14556

SWIGINTERN VALUE
_wrap_PVT_C_enu(int argc, VALUE *argv, VALUE self) {
  GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Matrix< double,Array2D_Dense< 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_User_PVTT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","C_enu", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  result = ((GPS_User_PVT< double > const *)arg1)->C_enu();
  vresult = SWIG_NewPointerObj((new Matrix< double,Array2D_Dense< double > >(static_cast< const Matrix< double,Array2D_Dense< double > >& >(result))), SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#delta_r(*args) ⇒ Object

call-seq:

delta_r -> Matrix_FrozenD

An instance method.



14457
14458
14459
14460
14461
14462
14463
14464
14465
14466
14467
14468
14469
14470
14471
14472
14473
14474
14475
14476
14477
14478
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14457

SWIGINTERN VALUE
_wrap_PVT_delta_r(int argc, VALUE *argv, VALUE self) {
  GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Matrix_Frozen< double,Array2D_Dense< 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_User_PVTT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","delta_r", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  result = (Matrix_Frozen< double,Array2D_Dense< double > > *) &((GPS_User_PVT< double > const *)arg1)->delta_r();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#error_code(*args) ⇒ Object

call-seq:

error_code -> int

An instance method.



13724
13725
13726
13727
13728
13729
13730
13731
13732
13733
13734
13735
13736
13737
13738
13739
13740
13741
13742
13743
13744
13745
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13724

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

#fd(*args) ⇒ Object

call-seq:

fd

An instance method.



14961
14962
14963
14964
14965
14966
14967
14968
14969
14970
14971
14972
14973
14974
14975
14976
14977
14978
14979
14980
14981
14982
14983
14984
14985
14986
14987
14988
14989
14990
14991
14992
14993
14994
14995
14996
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14961

SWIGINTERN VALUE
_wrap_PVT_fd(int argc, VALUE *argv, VALUE self) {
  GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
  GPS_User_PVT< double >::base_t::detection_t **arg2 = (GPS_User_PVT< double >::base_t::detection_t **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GPS_User_PVT< double >::base_t::detection_t *temp2 ;
  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_User_PVTT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","fd", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  ((GPS_User_PVT< double > const *)arg1)->fd((GPS_User_PVT< double >::base_t::detection_t const **)arg2);
  {
    if((*arg2)->valid){
      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->wssr));
      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->wssr_sf));
      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->weight_max));
      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->slope_HV[0].max));
      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int  (((*arg2)->slope_HV[0].prn)));
      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->slope_HV[1].max));
      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int  (((*arg2)->slope_HV[1].prn)));
    }
  }
  return vresult;
fail:
  return Qnil;
}

#fde_2nd(*args) ⇒ Object

call-seq:

fde_2nd

An instance method.



15080
15081
15082
15083
15084
15085
15086
15087
15088
15089
15090
15091
15092
15093
15094
15095
15096
15097
15098
15099
15100
15101
15102
15103
15104
15105
15106
15107
15108
15109
15110
15111
15112
15113
15114
15115
15116
15117
15118
15119
15120
15121
15122
15123
15124
15125
15126
15127
15128
15129
15130
15131
15132
15133
15134
15135
15136
15137
15138
15139
15140
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 15080

SWIGINTERN VALUE
_wrap_PVT_fde_2nd(int argc, VALUE *argv, VALUE self) {
  GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
  GPS_User_PVT< double >::base_t::detection_t **arg2 = (GPS_User_PVT< double >::base_t::detection_t **) 0 ;
  GPS_User_PVT< double >::base_t::exclusion_t **arg3 = (GPS_User_PVT< double >::base_t::exclusion_t **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GPS_User_PVT< double >::base_t::detection_t *temp2 ;
  GPS_User_PVT< double >::base_t::exclusion_t *temp3 ;
  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_User_PVTT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","fde_2nd", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  ((GPS_User_PVT< double > const *)arg1)->fde_2nd((GPS_User_PVT< double >::base_t::detection_t const **)arg2,(GPS_User_PVT< double >::base_t::exclusion_t const **)arg3);
  vresult = rb_ary_new();
  {
    if((*arg2)->valid){
      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->wssr));
      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->wssr_sf));
      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->weight_max));
      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->slope_HV[0].max));
      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int  (((*arg2)->slope_HV[0].prn)));
      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->slope_HV[1].max));
      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int  (((*arg2)->slope_HV[1].prn)));
    }
  }
  {
    if((*arg3)->valid){
      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int  (((*arg3)->excluded)));
      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(
          (new System_XYZ<double, WGS84>((*arg3)->user_position.xyz)),
          SWIGTYPE_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN))
      
      
      
      ;
      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(
          (new System_LLH<double, WGS84>((*arg3)->user_position.llh)),
          SWIGTYPE_System_LLHT_double_WGS84_t, SWIG_POINTER_OWN))
      
      
      
      ;
    }
  }
  return vresult;
fail:
  return Qnil;
}

#fde_min(*args) ⇒ Object

call-seq:

fde_min

An instance method.



15008
15009
15010
15011
15012
15013
15014
15015
15016
15017
15018
15019
15020
15021
15022
15023
15024
15025
15026
15027
15028
15029
15030
15031
15032
15033
15034
15035
15036
15037
15038
15039
15040
15041
15042
15043
15044
15045
15046
15047
15048
15049
15050
15051
15052
15053
15054
15055
15056
15057
15058
15059
15060
15061
15062
15063
15064
15065
15066
15067
15068
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 15008

SWIGINTERN VALUE
_wrap_PVT_fde_min(int argc, VALUE *argv, VALUE self) {
  GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
  GPS_User_PVT< double >::base_t::detection_t **arg2 = (GPS_User_PVT< double >::base_t::detection_t **) 0 ;
  GPS_User_PVT< double >::base_t::exclusion_t **arg3 = (GPS_User_PVT< double >::base_t::exclusion_t **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GPS_User_PVT< double >::base_t::detection_t *temp2 ;
  GPS_User_PVT< double >::base_t::exclusion_t *temp3 ;
  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_User_PVTT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","fde_min", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  ((GPS_User_PVT< double > const *)arg1)->fde_min((GPS_User_PVT< double >::base_t::detection_t const **)arg2,(GPS_User_PVT< double >::base_t::exclusion_t const **)arg3);
  vresult = rb_ary_new();
  {
    if((*arg2)->valid){
      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->wssr));
      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->wssr_sf));
      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->weight_max));
      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->slope_HV[0].max));
      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int  (((*arg2)->slope_HV[0].prn)));
      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((*arg2)->slope_HV[1].max));
      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int  (((*arg2)->slope_HV[1].prn)));
    }
  }
  {
    if((*arg3)->valid){
      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int  (((*arg3)->excluded)));
      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(
          (new System_XYZ<double, WGS84>((*arg3)->user_position.xyz)),
          SWIGTYPE_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN))
      
      
      
      ;
      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(
          (new System_LLH<double, WGS84>((*arg3)->user_position.llh)),
          SWIGTYPE_System_LLHT_double_WGS84_t, SWIG_POINTER_OWN))
      
      
      
      ;
    }
  }
  return vresult;
fail:
  return Qnil;
}

#G(*args) ⇒ Object

call-seq:

G -> Matrix_FrozenD

An instance method.



14391
14392
14393
14394
14395
14396
14397
14398
14399
14400
14401
14402
14403
14404
14405
14406
14407
14408
14409
14410
14411
14412
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14391

SWIGINTERN VALUE
_wrap_PVT_G(int argc, VALUE *argv, VALUE self) {
  GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Matrix_Frozen< double,Array2D_Dense< 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_User_PVTT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","G", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  result = (Matrix_Frozen< double,Array2D_Dense< double > > *) &((GPS_User_PVT< double > const *)arg1)->G();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#G_enu(*args) ⇒ Object

call-seq:

G_enu -> MatrixD

An instance method.



14490
14491
14492
14493
14494
14495
14496
14497
14498
14499
14500
14501
14502
14503
14504
14505
14506
14507
14508
14509
14510
14511
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14490

SWIGINTERN VALUE
_wrap_PVT_G_enu(int argc, VALUE *argv, VALUE self) {
  GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Matrix< double,Array2D_Dense< 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_User_PVTT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","G_enu", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  result = ((GPS_User_PVT< double > const *)arg1)->G_enu();
  vresult = SWIG_NewPointerObj((new Matrix< double,Array2D_Dense< double > >(static_cast< const Matrix< double,Array2D_Dense< double > >& >(result))), SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#gdop(*args) ⇒ Object

call-seq:

gdop -> double const &

An instance method.



13955
13956
13957
13958
13959
13960
13961
13962
13963
13964
13965
13966
13967
13968
13969
13970
13971
13972
13973
13974
13975
13976
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13955

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

#hdop(*args) ⇒ Object

call-seq:

hdop -> double const &

An instance method.



14021
14022
14023
14024
14025
14026
14027
14028
14029
14030
14031
14032
14033
14034
14035
14036
14037
14038
14039
14040
14041
14042
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14021

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

#hsigma(*args) ⇒ Object

call-seq:

hsigma -> double const &

An instance method.



14120
14121
14122
14123
14124
14125
14126
14127
14128
14129
14130
14131
14132
14133
14134
14135
14136
14137
14138
14139
14140
14141
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14120

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

#llh(*args) ⇒ Object

call-seq:

llh -> LLH

An instance method.



13823
13824
13825
13826
13827
13828
13829
13830
13831
13832
13833
13834
13835
13836
13837
13838
13839
13840
13841
13842
13843
13844
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13823

SWIGINTERN VALUE
_wrap_PVT_llh(int argc, VALUE *argv, VALUE self) {
  GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  System_LLH< double,WGS84 > 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_User_PVTT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","llh", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  result = ((GPS_User_PVT< double > const *)arg1)->llh();
  vresult = SWIG_NewPointerObj((new System_LLH< double,WGS84 >(static_cast< const System_LLH< double,WGS84 >& >(result))), SWIGTYPE_p_System_LLHT_double_WGS84_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#pdop(*args) ⇒ Object

call-seq:

pdop -> double const &

An instance method.



13988
13989
13990
13991
13992
13993
13994
13995
13996
13997
13998
13999
14000
14001
14002
14003
14004
14005
14006
14007
14008
14009
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13988

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

#position_solved?(*args) ⇒ Boolean

call-seq:

position_solved? -> bool

An instance method.

Returns:

  • (Boolean) 


14325
14326
14327
14328
14329
14330
14331
14332
14333
14334
14335
14336
14337
14338
14339
14340
14341
14342
14343
14344
14345
14346
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14325

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

#receiver_error(*args) ⇒ Object

call-seq:

receiver_error -> double const &

An instance method.



13856
13857
13858
13859
13860
13861
13862
13863
13864
13865
13866
13867
13868
13869
13870
13871
13872
13873
13874
13875
13876
13877
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13856

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

#receiver_error_rate(*args) ⇒ Object

call-seq:

receiver_error_rate -> double const &

An instance method.



13922
13923
13924
13925
13926
13927
13928
13929
13930
13931
13932
13933
13934
13935
13936
13937
13938
13939
13940
13941
13942
13943
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13922

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

#receiver_time(*args) ⇒ Object

call-seq:

receiver_time -> Time

An instance method.



13757
13758
13759
13760
13761
13762
13763
13764
13765
13766
13767
13768
13769
13770
13771
13772
13773
13774
13775
13776
13777
13778
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13757

SWIGINTERN VALUE
_wrap_PVT_receiver_time(int argc, VALUE *argv, VALUE self) {
  GPS_User_PVT< double > *arg1 = (GPS_User_PVT< 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_User_PVTT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","receiver_time", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  result = ((GPS_User_PVT< double > const *)arg1)->receiver_time();
  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;
}

#S(*args) ⇒ Object

call-seq:

S -> MatrixD

An instance method.



14589
14590
14591
14592
14593
14594
14595
14596
14597
14598
14599
14600
14601
14602
14603
14604
14605
14606
14607
14608
14609
14610
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14589

SWIGINTERN VALUE
_wrap_PVT_S(int argc, VALUE *argv, VALUE self) {
  GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Matrix< double,Array2D_Dense< 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_User_PVTT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","S", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  result = ((GPS_User_PVT< double > const *)arg1)->S();
  vresult = SWIG_NewPointerObj((new Matrix< double,Array2D_Dense< double > >(static_cast< const Matrix< double,Array2D_Dense< double > >& >(result))), SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#S_enu(*args, self) ⇒ Object

call-seq:

S_enu(MatrixD s) -> MatrixD
S_enu -> MatrixD

An instance method.



14682
14683
14684
14685
14686
14687
14688
14689
14690
14691
14692
14693
14694
14695
14696
14697
14698
14699
14700
14701
14702
14703
14704
14705
14706
14707
14708
14709
14710
14711
14712
14713
14714
14715
14716
14717
14718
14719
14720
14721
14722
14723
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14682

SWIGINTERN VALUE _wrap_PVT_S_enu(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_User_PVTT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PVT_S_enu__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_User_PVTT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PVT_S_enu__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PVT.S_enu", 
    "    Matrix< double,Array2D_Dense< double > > PVT.S_enu(Matrix< double,Array2D_Dense< double > > const &s)\n"
    "    Matrix< double,Array2D_Dense< double > > PVT.S_enu()\n");
  
  return Qnil;
}

#slope_HV(*args, self) ⇒ Object

call-seq:

slope_HV(MatrixD s) -> MatrixD
slope_HV -> MatrixD

An instance method.



14795
14796
14797
14798
14799
14800
14801
14802
14803
14804
14805
14806
14807
14808
14809
14810
14811
14812
14813
14814
14815
14816
14817
14818
14819
14820
14821
14822
14823
14824
14825
14826
14827
14828
14829
14830
14831
14832
14833
14834
14835
14836
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14795

SWIGINTERN VALUE _wrap_PVT_slope_HV(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_User_PVTT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PVT_slope_HV__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_User_PVTT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PVT_slope_HV__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PVT.slope_HV", 
    "    Matrix< double,Array2D_Dense< double > > PVT.slope_HV(Matrix< double,Array2D_Dense< double > > const &s)\n"
    "    Matrix< double,Array2D_Dense< double > > PVT.slope_HV()\n");
  
  return Qnil;
}

#slope_HV_enu(*args, self) ⇒ Object

call-seq:

slope_HV_enu(MatrixD s) -> MatrixD
slope_HV_enu -> MatrixD

An instance method.



14908
14909
14910
14911
14912
14913
14914
14915
14916
14917
14918
14919
14920
14921
14922
14923
14924
14925
14926
14927
14928
14929
14930
14931
14932
14933
14934
14935
14936
14937
14938
14939
14940
14941
14942
14943
14944
14945
14946
14947
14948
14949
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14908

SWIGINTERN VALUE _wrap_PVT_slope_HV_enu(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_User_PVTT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PVT_slope_HV_enu__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_User_PVTT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PVT_slope_HV_enu__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PVT.slope_HV_enu", 
    "    Matrix< double,Array2D_Dense< double > > PVT.slope_HV_enu(Matrix< double,Array2D_Dense< double > > const &s)\n"
    "    Matrix< double,Array2D_Dense< double > > PVT.slope_HV_enu()\n");
  
  return Qnil;
}

#tdop(*args) ⇒ Object

call-seq:

tdop -> double const &

An instance method.



14087
14088
14089
14090
14091
14092
14093
14094
14095
14096
14097
14098
14099
14100
14101
14102
14103
14104
14105
14106
14107
14108
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14087

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

#tsigma(*args) ⇒ Object

call-seq:

tsigma -> double const &

An instance method.



14186
14187
14188
14189
14190
14191
14192
14193
14194
14195
14196
14197
14198
14199
14200
14201
14202
14203
14204
14205
14206
14207
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14186

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

#used_satellite_list(*args) ⇒ Object

call-seq:

used_satellite_list -> std::vector< int >

An instance method.



14285
14286
14287
14288
14289
14290
14291
14292
14293
14294
14295
14296
14297
14298
14299
14300
14301
14302
14303
14304
14305
14306
14307
14308
14309
14310
14311
14312
14313
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14285

SWIGINTERN VALUE
_wrap_PVT_used_satellite_list(int argc, VALUE *argv, VALUE self) {
  GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< 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_User_PVTT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","used_satellite_list", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  result = ((GPS_User_PVT< double > const *)arg1)->used_satellite_list();
  {
    vresult = rb_ary_new();
    
    for(std::vector< int >::const_iterator it((&result)->begin()), it_end((&result)->end());
      it != it_end; ++it){
      vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int  (*it));
    }
  }
  return vresult;
fail:
  return Qnil;
}

#used_satellites(*args) ⇒ Object

call-seq:

used_satellites -> unsigned int const &

An instance method.



14252
14253
14254
14255
14256
14257
14258
14259
14260
14261
14262
14263
14264
14265
14266
14267
14268
14269
14270
14271
14272
14273
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14252

SWIGINTERN VALUE
_wrap_PVT_used_satellites(int argc, VALUE *argv, VALUE self) {
  GPS_User_PVT< double > *arg1 = (GPS_User_PVT< 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_User_PVTT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","used_satellites", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  result = (unsigned int *) &((GPS_User_PVT< double > const *)arg1)->used_satellites();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(*result));
  return vresult;
fail:
  return Qnil;
}

#vdop(*args) ⇒ Object

call-seq:

vdop -> double const &

An instance method.



14054
14055
14056
14057
14058
14059
14060
14061
14062
14063
14064
14065
14066
14067
14068
14069
14070
14071
14072
14073
14074
14075
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14054

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

#vel_sigma(*args) ⇒ Object

call-seq:

vel_sigma -> double const &

An instance method.



14219
14220
14221
14222
14223
14224
14225
14226
14227
14228
14229
14230
14231
14232
14233
14234
14235
14236
14237
14238
14239
14240
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14219

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

#velocity(*args) ⇒ Object

call-seq:

velocity -> ENU

An instance method.



13889
13890
13891
13892
13893
13894
13895
13896
13897
13898
13899
13900
13901
13902
13903
13904
13905
13906
13907
13908
13909
13910
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13889

SWIGINTERN VALUE
_wrap_PVT_velocity(int argc, VALUE *argv, VALUE self) {
  GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  System_ENU< double,WGS84 > 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_User_PVTT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","velocity", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  result = ((GPS_User_PVT< double > const *)arg1)->velocity();
  vresult = SWIG_NewPointerObj((new System_ENU< double,WGS84 >(static_cast< const System_ENU< double,WGS84 >& >(result))), SWIGTYPE_p_System_ENUT_double_WGS84_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#velocity_solved?(*args) ⇒ Boolean

call-seq:

velocity_solved? -> bool

An instance method.

Returns:

  • (Boolean) 


14358
14359
14360
14361
14362
14363
14364
14365
14366
14367
14368
14369
14370
14371
14372
14373
14374
14375
14376
14377
14378
14379
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14358

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

#vsigma(*args) ⇒ Object

call-seq:

vsigma -> double const &

An instance method.



14153
14154
14155
14156
14157
14158
14159
14160
14161
14162
14163
14164
14165
14166
14167
14168
14169
14170
14171
14172
14173
14174
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14153

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

#W(*args) ⇒ Object

call-seq:

W -> Matrix_FrozenD

An instance method.



14424
14425
14426
14427
14428
14429
14430
14431
14432
14433
14434
14435
14436
14437
14438
14439
14440
14441
14442
14443
14444
14445
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14424

SWIGINTERN VALUE
_wrap_PVT_W(int argc, VALUE *argv, VALUE self) {
  GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Matrix_Frozen< double,Array2D_Dense< 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_User_PVTT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","W", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  result = (Matrix_Frozen< double,Array2D_Dense< double > > *) &((GPS_User_PVT< double > const *)arg1)->W();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#xyz(*args) ⇒ Object

call-seq:

xyz -> XYZ

An instance method.



13790
13791
13792
13793
13794
13795
13796
13797
13798
13799
13800
13801
13802
13803
13804
13805
13806
13807
13808
13809
13810
13811
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13790

SWIGINTERN VALUE
_wrap_PVT_xyz(int argc, VALUE *argv, VALUE self) {
  GPS_User_PVT< double > *arg1 = (GPS_User_PVT< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  System_XYZ< double,WGS84 > 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_User_PVTT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_User_PVT< double > const *","xyz", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  result = ((GPS_User_PVT< double > const *)arg1)->xyz();
  vresult = SWIG_NewPointerObj((new System_XYZ< double,WGS84 >(static_cast< const System_XYZ< double,WGS84 >& >(result))), SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}