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.



12913
12914
12915
12916
12917
12918
12919
12920
12921
12922
12923
12924
12925
12926
12927
12928
12929
12930
12931
12932
12933
12934
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 12913

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;
  }
  {
    try {
      result = (GPS_User_PVT< double > *)new GPS_User_PVT< 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;
}

Instance Method Details

#C(*args) ⇒ Object

call-seq:

C -> MatrixD

An instance method.



13883
13884
13885
13886
13887
13888
13889
13890
13891
13892
13893
13894
13895
13896
13897
13898
13899
13900
13901
13902
13903
13904
13905
13906
13907
13908
13909
13910
13911
13912
13913
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13883

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);
  {
    try {
      result = ((GPS_User_PVT< double > const *)arg1)->C();
    } 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 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.



13925
13926
13927
13928
13929
13930
13931
13932
13933
13934
13935
13936
13937
13938
13939
13940
13941
13942
13943
13944
13945
13946
13947
13948
13949
13950
13951
13952
13953
13954
13955
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13925

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);
  {
    try {
      result = ((GPS_User_PVT< double > const *)arg1)->C_enu();
    } 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 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.



13799
13800
13801
13802
13803
13804
13805
13806
13807
13808
13809
13810
13811
13812
13813
13814
13815
13816
13817
13818
13819
13820
13821
13822
13823
13824
13825
13826
13827
13828
13829
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13799

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);
  {
    try {
      result = (Matrix_Frozen< double,Array2D_Dense< double > > *) &((GPS_User_PVT< double > const *)arg1)->delta_r();
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  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.



13036
13037
13038
13039
13040
13041
13042
13043
13044
13045
13046
13047
13048
13049
13050
13051
13052
13053
13054
13055
13056
13057
13058
13059
13060
13061
13062
13063
13064
13065
13066
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13036

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);
  {
    try {
      result = (int)((GPS_User_PVT< double > const *)arg1)->error_code();
    } 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;
}

#fd(*args) ⇒ Object

call-seq:

fd

An instance method.



14135
14136
14137
14138
14139
14140
14141
14142
14143
14144
14145
14146
14147
14148
14149
14150
14151
14152
14153
14154
14155
14156
14157
14158
14159
14160
14161
14162
14163
14164
14165
14166
14167
14168
14169
14170
14171
14172
14173
14174
14175
14176
14177
14178
14179
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14135

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);
  {
    try {
      ((GPS_User_PVT< double > const *)arg1)->fd((GPS_User_PVT< double >::base_t::detection_t const **)arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  {
    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.



14272
14273
14274
14275
14276
14277
14278
14279
14280
14281
14282
14283
14284
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
14314
14315
14316
14317
14318
14319
14320
14321
14322
14323
14324
14325
14326
14327
14328
14329
14330
14331
14332
14333
14334
14335
14336
14337
14338
14339
14340
14341
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14272

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);
  {
    try {
      ((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);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = rb_ary_new();
  {
    if((*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.



14191
14192
14193
14194
14195
14196
14197
14198
14199
14200
14201
14202
14203
14204
14205
14206
14207
14208
14209
14210
14211
14212
14213
14214
14215
14216
14217
14218
14219
14220
14221
14222
14223
14224
14225
14226
14227
14228
14229
14230
14231
14232
14233
14234
14235
14236
14237
14238
14239
14240
14241
14242
14243
14244
14245
14246
14247
14248
14249
14250
14251
14252
14253
14254
14255
14256
14257
14258
14259
14260
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14191

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);
  {
    try {
      ((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);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = rb_ary_new();
  {
    if((*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.



13715
13716
13717
13718
13719
13720
13721
13722
13723
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 13715

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);
  {
    try {
      result = (Matrix_Frozen< double,Array2D_Dense< double > > *) &((GPS_User_PVT< double > const *)arg1)->G();
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  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.



13841
13842
13843
13844
13845
13846
13847
13848
13849
13850
13851
13852
13853
13854
13855
13856
13857
13858
13859
13860
13861
13862
13863
13864
13865
13866
13867
13868
13869
13870
13871
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13841

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);
  {
    try {
      result = ((GPS_User_PVT< double > const *)arg1)->G_enu();
    } 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 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.



13330
13331
13332
13333
13334
13335
13336
13337
13338
13339
13340
13341
13342
13343
13344
13345
13346
13347
13348
13349
13350
13351
13352
13353
13354
13355
13356
13357
13358
13359
13360
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13330

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);
  {
    try {
      result = (double *) &((GPS_User_PVT< double > const *)arg1)->gdop();
    } 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;
}

#hdop(*args) ⇒ Object

call-seq:

hdop -> double const &

An instance method.



13414
13415
13416
13417
13418
13419
13420
13421
13422
13423
13424
13425
13426
13427
13428
13429
13430
13431
13432
13433
13434
13435
13436
13437
13438
13439
13440
13441
13442
13443
13444
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13414

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);
  {
    try {
      result = (double *) &((GPS_User_PVT< double > const *)arg1)->hdop();
    } 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;
}

#llh(*args) ⇒ Object

call-seq:

llh -> LLH

An instance method.



13162
13163
13164
13165
13166
13167
13168
13169
13170
13171
13172
13173
13174
13175
13176
13177
13178
13179
13180
13181
13182
13183
13184
13185
13186
13187
13188
13189
13190
13191
13192
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13162

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 = 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 *","llh", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  {
    try {
      result = (System_LLH< double,WGS84 > *) &((GPS_User_PVT< double > const *)arg1)->llh();
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_System_LLHT_double_WGS84_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#pdop(*args) ⇒ Object

call-seq:

pdop -> double const &

An instance method.



13372
13373
13374
13375
13376
13377
13378
13379
13380
13381
13382
13383
13384
13385
13386
13387
13388
13389
13390
13391
13392
13393
13394
13395
13396
13397
13398
13399
13400
13401
13402
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13372

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);
  {
    try {
      result = (double *) &((GPS_User_PVT< double > const *)arg1)->pdop();
    } 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;
}

#position_solved?(*args) ⇒ Boolean

call-seq:

position_solved? -> bool

An instance method.

Returns:

  • (Boolean) 


13631
13632
13633
13634
13635
13636
13637
13638
13639
13640
13641
13642
13643
13644
13645
13646
13647
13648
13649
13650
13651
13652
13653
13654
13655
13656
13657
13658
13659
13660
13661
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13631

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);
  {
    try {
      result = (bool)((GPS_User_PVT< double > const *)arg1)->position_solved();
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#receiver_error(*args) ⇒ Object

call-seq:

receiver_error -> double const &

An instance method.



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

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);
  {
    try {
      result = (double *) &((GPS_User_PVT< double > const *)arg1)->receiver_error();
    } 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;
}

#receiver_error_rate(*args) ⇒ Object

call-seq:

receiver_error_rate -> double const &

An instance method.



13288
13289
13290
13291
13292
13293
13294
13295
13296
13297
13298
13299
13300
13301
13302
13303
13304
13305
13306
13307
13308
13309
13310
13311
13312
13313
13314
13315
13316
13317
13318
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13288

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);
  {
    try {
      result = (double *) &((GPS_User_PVT< double > const *)arg1)->receiver_error_rate();
    } 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;
}

#receiver_time(*args) ⇒ Object

call-seq:

receiver_time -> Time

An instance method.



13078
13079
13080
13081
13082
13083
13084
13085
13086
13087
13088
13089
13090
13091
13092
13093
13094
13095
13096
13097
13098
13099
13100
13101
13102
13103
13104
13105
13106
13107
13108
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13078

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 = 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_time", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  {
    try {
      result = (GPS_Time< double > *) &((GPS_User_PVT< double > const *)arg1)->receiver_time();
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GPS_TimeT_double_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#S(*args) ⇒ Object

call-seq:

S -> MatrixD

An instance method.



13967
13968
13969
13970
13971
13972
13973
13974
13975
13976
13977
13978
13979
13980
13981
13982
13983
13984
13985
13986
13987
13988
13989
13990
13991
13992
13993
13994
13995
13996
13997
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13967

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);
  {
    try {
      result = ((GPS_User_PVT< double > const *)arg1)->S();
    } 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 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) ⇒ Object

call-seq:

S_enu -> MatrixD

An instance method.



14009
14010
14011
14012
14013
14014
14015
14016
14017
14018
14019
14020
14021
14022
14023
14024
14025
14026
14027
14028
14029
14030
14031
14032
14033
14034
14035
14036
14037
14038
14039
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14009

SWIGINTERN VALUE
_wrap_PVT_S_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 *","S_enu", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  {
    try {
      result = ((GPS_User_PVT< double > const *)arg1)->S_enu();
    } 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 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;
}

#slope_HV(*args) ⇒ Object

call-seq:

slope_HV -> MatrixD

An instance method.



14051
14052
14053
14054
14055
14056
14057
14058
14059
14060
14061
14062
14063
14064
14065
14066
14067
14068
14069
14070
14071
14072
14073
14074
14075
14076
14077
14078
14079
14080
14081
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14051

SWIGINTERN VALUE
_wrap_PVT_slope_HV(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 *","slope_HV", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  {
    try {
      result = ((GPS_User_PVT< double > const *)arg1)->slope_HV();
    } 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 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;
}

#slope_HV_enu(*args) ⇒ Object

call-seq:

slope_HV_enu -> MatrixD

An instance method.



14093
14094
14095
14096
14097
14098
14099
14100
14101
14102
14103
14104
14105
14106
14107
14108
14109
14110
14111
14112
14113
14114
14115
14116
14117
14118
14119
14120
14121
14122
14123
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 14093

SWIGINTERN VALUE
_wrap_PVT_slope_HV_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 *","slope_HV_enu", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  {
    try {
      result = ((GPS_User_PVT< double > const *)arg1)->slope_HV_enu();
    } 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 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;
}

#tdop(*args) ⇒ Object

call-seq:

tdop -> double const &

An instance method.



13498
13499
13500
13501
13502
13503
13504
13505
13506
13507
13508
13509
13510
13511
13512
13513
13514
13515
13516
13517
13518
13519
13520
13521
13522
13523
13524
13525
13526
13527
13528
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13498

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);
  {
    try {
      result = (double *) &((GPS_User_PVT< double > const *)arg1)->tdop();
    } 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;
}

#used_satellite_list(*args) ⇒ Object

call-seq:

used_satellite_list -> std::vector< int >

An instance method.



13582
13583
13584
13585
13586
13587
13588
13589
13590
13591
13592
13593
13594
13595
13596
13597
13598
13599
13600
13601
13602
13603
13604
13605
13606
13607
13608
13609
13610
13611
13612
13613
13614
13615
13616
13617
13618
13619
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13582

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);
  {
    try {
      result = ((GPS_User_PVT< double > const *)arg1)->used_satellite_list();
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  {
    vresult = rb_ary_new();
    
    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.



13540
13541
13542
13543
13544
13545
13546
13547
13548
13549
13550
13551
13552
13553
13554
13555
13556
13557
13558
13559
13560
13561
13562
13563
13564
13565
13566
13567
13568
13569
13570
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13540

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);
  {
    try {
      result = (unsigned int *) &((GPS_User_PVT< double > const *)arg1)->used_satellites();
    } 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;
}

#vdop(*args) ⇒ Object

call-seq:

vdop -> double const &

An instance method.



13456
13457
13458
13459
13460
13461
13462
13463
13464
13465
13466
13467
13468
13469
13470
13471
13472
13473
13474
13475
13476
13477
13478
13479
13480
13481
13482
13483
13484
13485
13486
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13456

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);
  {
    try {
      result = (double *) &((GPS_User_PVT< double > const *)arg1)->vdop();
    } 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;
}

#velocity(*args) ⇒ Object

call-seq:

velocity -> ENU

An instance method.



13246
13247
13248
13249
13250
13251
13252
13253
13254
13255
13256
13257
13258
13259
13260
13261
13262
13263
13264
13265
13266
13267
13268
13269
13270
13271
13272
13273
13274
13275
13276
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13246

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 = 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 *","velocity", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  {
    try {
      result = (System_ENU< double,WGS84 > *) &((GPS_User_PVT< double > const *)arg1)->velocity();
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_System_ENUT_double_WGS84_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#velocity_solved?(*args) ⇒ Boolean

call-seq:

velocity_solved? -> bool

An instance method.

Returns:

  • (Boolean) 


13673
13674
13675
13676
13677
13678
13679
13680
13681
13682
13683
13684
13685
13686
13687
13688
13689
13690
13691
13692
13693
13694
13695
13696
13697
13698
13699
13700
13701
13702
13703
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13673

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);
  {
    try {
      result = (bool)((GPS_User_PVT< double > const *)arg1)->velocity_solved();
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#W(*args) ⇒ Object

call-seq:

W -> Matrix_FrozenD

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
13779
13780
13781
13782
13783
13784
13785
13786
13787
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13757

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);
  {
    try {
      result = (Matrix_Frozen< double,Array2D_Dense< double > > *) &((GPS_User_PVT< double > const *)arg1)->W();
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  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.



13120
13121
13122
13123
13124
13125
13126
13127
13128
13129
13130
13131
13132
13133
13134
13135
13136
13137
13138
13139
13140
13141
13142
13143
13144
13145
13146
13147
13148
13149
13150
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 13120

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 = 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 *","xyz", 1, self )); 
  }
  arg1 = reinterpret_cast< GPS_User_PVT< double > * >(argp1);
  {
    try {
      result = (System_XYZ< double,WGS84 > *) &((GPS_User_PVT< double > const *)arg1)->xyz();
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_System_XYZT_double_WGS84_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}