Class: GPS_PVT::GPS::SP3

Inherits:
((swig_class *) SWIGTYPE_p_PushableData->clientdata)->klass
  • Object
show all
Defined in:
ext/gps_pvt/GPS/GPS_wrap.cxx

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object

call-seq:

SP3.new

Class constructor.



24792
24793
24794
24795
24796
24797
24798
24799
24800
24801
24802
24803
24804
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 24792

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

Instance Method Details

#apply_antex(*args) ⇒ Object

call-seq:

apply_antex(char const * fname) -> int

An instance method.



24733
24734
24735
24736
24737
24738
24739
24740
24741
24742
24743
24744
24745
24746
24747
24748
24749
24750
24751
24752
24753
24754
24755
24756
24757
24758
24759
24760
24761
24762
24763
24764
24765
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 24733

SWIGINTERN VALUE
_wrap_SP3_apply_antex(int argc, VALUE *argv, VALUE self) {
  SP3< double > *arg1 = (SP3< double > *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SP3T_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SP3< double > *","apply_antex", 1, self )); 
  }
  arg1 = reinterpret_cast< SP3< double > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","apply_antex", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (int)(arg1)->apply_antex((char const *)arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}

#clock_error(*args) ⇒ Object

call-seq:

clock_error(int const & sat_id, Time t) -> double

An instance method.



24625
24626
24627
24628
24629
24630
24631
24632
24633
24634
24635
24636
24637
24638
24639
24640
24641
24642
24643
24644
24645
24646
24647
24648
24649
24650
24651
24652
24653
24654
24655
24656
24657
24658
24659
24660
24661
24662
24663
24664
24665
24666
24667
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 24625

SWIGINTERN VALUE
_wrap_SP3_clock_error(int argc, VALUE *argv, VALUE self) {
  SP3< double > *arg1 = (SP3< double > *) 0 ;
  int *arg2 = 0 ;
  GPS_Time< double > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SP3T_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SP3< double > const *","clock_error", 1, self )); 
  }
  arg1 = reinterpret_cast< SP3< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","clock_error", 2, argv[0] ));
  } 
  temp2 = static_cast< int >(val2);
  arg2 = &temp2;
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_GPS_TimeT_double_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "GPS_Time< double > const &","clock_error", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","clock_error", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< GPS_Time< double > * >(argp3);
  result = (double)((SP3< double > const *)arg1)->clock_error((int const &)*arg2,(GPS_Time< double > const &)*arg3);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#clock_error_dot(*args) ⇒ Object

call-seq:

clock_error_dot(int const & sat_id, Time t) -> double

An instance method.



24679
24680
24681
24682
24683
24684
24685
24686
24687
24688
24689
24690
24691
24692
24693
24694
24695
24696
24697
24698
24699
24700
24701
24702
24703
24704
24705
24706
24707
24708
24709
24710
24711
24712
24713
24714
24715
24716
24717
24718
24719
24720
24721
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 24679

SWIGINTERN VALUE
_wrap_SP3_clock_error_dot(int argc, VALUE *argv, VALUE self) {
  SP3< double > *arg1 = (SP3< double > *) 0 ;
  int *arg2 = 0 ;
  GPS_Time< double > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SP3T_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SP3< double > const *","clock_error_dot", 1, self )); 
  }
  arg1 = reinterpret_cast< SP3< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","clock_error_dot", 2, argv[0] ));
  } 
  temp2 = static_cast< int >(val2);
  arg2 = &temp2;
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_GPS_TimeT_double_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "GPS_Time< double > const &","clock_error_dot", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","clock_error_dot", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< GPS_Time< double > * >(argp3);
  result = (double)((SP3< double > const *)arg1)->clock_error_dot((int const &)*arg2,(GPS_Time< double > const &)*arg3);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#position(*args) ⇒ Object

call-seq:

position(int const & sat_id, Time t) -> XYZ

An instance method.



24517
24518
24519
24520
24521
24522
24523
24524
24525
24526
24527
24528
24529
24530
24531
24532
24533
24534
24535
24536
24537
24538
24539
24540
24541
24542
24543
24544
24545
24546
24547
24548
24549
24550
24551
24552
24553
24554
24555
24556
24557
24558
24559
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 24517

SWIGINTERN VALUE
_wrap_SP3_position(int argc, VALUE *argv, VALUE self) {
  SP3< double > *arg1 = (SP3< double > *) 0 ;
  int *arg2 = 0 ;
  GPS_Time< double > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  System_XYZ< double,WGS84 > result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SP3T_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SP3< double > const *","position", 1, self )); 
  }
  arg1 = reinterpret_cast< SP3< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","position", 2, argv[0] ));
  } 
  temp2 = static_cast< int >(val2);
  arg2 = &temp2;
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_GPS_TimeT_double_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "GPS_Time< double > const &","position", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","position", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< GPS_Time< double > * >(argp3);
  result = ((SP3< double > const *)arg1)->position((int const &)*arg2,(GPS_Time< double > const &)*arg3);
  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;
}

#push(*args, self) ⇒ Object

call-seq:

push(solver, sys) -> bool
push(solver) -> bool

Add an element at the end of the SP3.



24453
24454
24455
24456
24457
24458
24459
24460
24461
24462
24463
24464
24465
24466
24467
24468
24469
24470
24471
24472
24473
24474
24475
24476
24477
24478
24479
24480
24481
24482
24483
24484
24485
24486
24487
24488
24489
24490
24491
24492
24493
24494
24495
24496
24497
24498
24499
24500
24501
24502
24503
24504
24505
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 24453

SWIGINTERN VALUE _wrap_SP3_push(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SP3T_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPS_SolverT_double_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SP3_push__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SP3T_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPS_SolverT_double_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SP3_push__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SP3.push", 
    "    bool SP3.push(GPS_Solver< double > &solver, PushableData::system_t const &sys)\n"
    "    bool SP3.push(GPS_Solver< double > &solver)\n");
  
  return Qnil;
}

#read(*args) ⇒ Object

call-seq:

read(char const * fname) -> int

An instance method.



24288
24289
24290
24291
24292
24293
24294
24295
24296
24297
24298
24299
24300
24301
24302
24303
24304
24305
24306
24307
24308
24309
24310
24311
24312
24313
24314
24315
24316
24317
24318
24319
24320
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 24288

SWIGINTERN VALUE
_wrap_SP3_read(int argc, VALUE *argv, VALUE self) {
  SP3< double > *arg1 = (SP3< double > *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SP3T_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SP3< double > *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< SP3< double > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","read", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (int)(arg1)->read((char const *)arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}

#satellites(*args) ⇒ Object

call-seq:

satellites -> SP3_Product< double >::satellite_count_t

An instance method.



24332
24333
24334
24335
24336
24337
24338
24339
24340
24341
24342
24343
24344
24345
24346
24347
24348
24349
24350
24351
24352
24353
24354
24355
24356
24357
24358
24359
24360
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 24332

SWIGINTERN VALUE
_wrap_SP3_satellites(int argc, VALUE *argv, VALUE self) {
  SP3< double > *arg1 = (SP3< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SP3_Product< double >::satellite_count_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SP3T_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SP3< double > const *","satellites", 1, self )); 
  }
  arg1 = reinterpret_cast< SP3< double > * >(argp1);
  result = ((SP3< double > const *)arg1)->satellites();
  {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int  ((&result)->gps));
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int  ((&result)->sbas));
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int  ((&result)->qzss));
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int  ((&result)->glonass));
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int  ((&result)->galileo));
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int  ((&result)->beidou));
  }
  return vresult;
fail:
  return Qnil;
}

#velocity(*args) ⇒ Object

call-seq:

velocity(int const & sat_id, Time t) -> XYZ

An instance method.



24571
24572
24573
24574
24575
24576
24577
24578
24579
24580
24581
24582
24583
24584
24585
24586
24587
24588
24589
24590
24591
24592
24593
24594
24595
24596
24597
24598
24599
24600
24601
24602
24603
24604
24605
24606
24607
24608
24609
24610
24611
24612
24613
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 24571

SWIGINTERN VALUE
_wrap_SP3_velocity(int argc, VALUE *argv, VALUE self) {
  SP3< double > *arg1 = (SP3< double > *) 0 ;
  int *arg2 = 0 ;
  GPS_Time< double > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  System_XYZ< double,WGS84 > result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SP3T_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SP3< double > const *","velocity", 1, self )); 
  }
  arg1 = reinterpret_cast< SP3< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","velocity", 2, argv[0] ));
  } 
  temp2 = static_cast< int >(val2);
  arg2 = &temp2;
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_GPS_TimeT_double_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "GPS_Time< double > const &","velocity", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","velocity", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< GPS_Time< double > * >(argp3);
  result = ((SP3< double > const *)arg1)->velocity((int const &)*arg2,(GPS_Time< double > const &)*arg3);
  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;
}