Class: GPS_PVT::SylphideMath::ComplexD

Inherits:
Object
  • Object
show all
Defined in:
ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx,
ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx

Overview

Proxy of C++ GPS_PVT::SylphideMath::ComplexD class

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(*args, self) ⇒ Object 



6012
6013
6014
6015
6016
6017
6018
6019
6020
6021
6022
6023
6024
6025
6026
6027
6028
6029
6030
6031
6032
6033
6034
6035
6036
6037
6038
6039
6040
6041
6042
6043
6044
6045
6046
6047
6048
6049
6050
6051
6052
6053
6054
6055
6056
6057
6058
6059
6060
6061
6062
6063
6064
6065
6066
6067
6068
6069
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 6012

SWIGINTERN VALUE _wrap_new_ComplexD(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ComplexD__SWIG_2(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      _v = swig::check<Complex< double > * >(argv[0]) || swig::check<Complex< double > >(argv[0]);
    }
    if (_v) {
      return _wrap_new_ComplexD__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ComplexD__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ComplexD__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "ComplexD.new", 
    "    ComplexD.new(double const &real, double const &imaginary)\n"
    "    ComplexD.new(double const &real)\n"
    "    ComplexD.new()\n"
    "    ComplexD.new(Complex< double > const &other)\n");
  
  return Qnil;
}

Class Method Details

.exp(*args, self) ⇒ Object 



5599
5600
5601
5602
5603
5604
5605
5606
5607
5608
5609
5610
5611
5612
5613
5614
5615
5616
5617
5618
5619
5620
5621
5622
5623
5624
5625
5626
5627
5628
5629
5630
5631
5632
5633
5634
5635
5636
5637
5638
5639
5640
5641
5642
5643
5644
5645
5646
5647
5648
5649
5650
5651
5652
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 5599

SWIGINTERN VALUE _wrap_ComplexD_exp(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    {
      _v = swig::check<Complex< double > * >(argv[0]) || swig::check<Complex< double > >(argv[0]);
    }
    if (_v) {
      return _wrap_ComplexD_exp__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_ComplexD_exp__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ComplexD_exp__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "ComplexD.exp", 
    "    Complex< double > ComplexD.exp(double const &imaginary)\n"
    "    Complex< double > ComplexD.exp(double const &real, double const &imaginary)\n"
    "    Complex< double > ComplexD.exp(Complex< double > const &complex)\n");
  
  return Qnil;
}

.polar(*args, self) ⇒ Object 



4540
4541
4542
4543
4544
4545
4546
4547
4548
4549
4550
4551
4552
4553
4554
4555
4556
4557
4558
4559
4560
4561
4562
4563
4564
4565
4566
4567
4568
4569
4570
4571
4572
4573
4574
4575
4576
4577
4578
4579
4580
4581
4582
4583
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 4540

SWIGINTERN VALUE _wrap_ComplexD_polar(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_ComplexD_polar__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ComplexD_polar__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "ComplexD.polar", 
    "    Complex< double > ComplexD.polar(double const &r, double const &theta)\n"
    "    Complex< double > ComplexD.polar(double const &r)\n");
  
  return Qnil;
}

.rectangular(*args, self) ⇒ Object 



5731
5732
5733
5734
5735
5736
5737
5738
5739
5740
5741
5742
5743
5744
5745
5746
5747
5748
5749
5750
5751
5752
5753
5754
5755
5756
5757
5758
5759
5760
5761
5762
5763
5764
5765
5766
5767
5768
5769
5770
5771
5772
5773
5774
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 5731

SWIGINTERN VALUE _wrap_ComplexD_rectangular(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_ComplexD_rectangular__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ComplexD_rectangular__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "rectangular", 
    "    Complex< double > rectangular(double const &r, double const &i)\n"
    "    Complex< double > rectangular(double const &r)\n");
  
  return Qnil;
}

Instance Method Details

#*(*args, self) ⇒ Object 



5352
5353
5354
5355
5356
5357
5358
5359
5360
5361
5362
5363
5364
5365
5366
5367
5368
5369
5370
5371
5372
5373
5374
5375
5376
5377
5378
5379
5380
5381
5382
5383
5384
5385
5386
5387
5388
5389
5390
5391
5392
5393
5394
5395
5396
5397
5398
5399
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 5352

SWIGINTERN VALUE _wrap_ComplexD___mul__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ComplexT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = swig::check<Complex< double > * >(argv[1]) || swig::check<Complex< double > >(argv[1]);
      }
      if (_v) {
        return _wrap_ComplexD___mul____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ComplexT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ComplexD___mul____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ComplexD.__mul__", 
    "    Complex< double > ComplexD.__mul__(double const &scalar)\n"
    "    Complex< double > ComplexD.__mul__(Complex< double > const &complex)\n");
  
  return Qnil;
}

#+(*args, self) ⇒ Object 



5165
5166
5167
5168
5169
5170
5171
5172
5173
5174
5175
5176
5177
5178
5179
5180
5181
5182
5183
5184
5185
5186
5187
5188
5189
5190
5191
5192
5193
5194
5195
5196
5197
5198
5199
5200
5201
5202
5203
5204
5205
5206
5207
5208
5209
5210
5211
5212
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 5165

SWIGINTERN VALUE _wrap_ComplexD___add__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ComplexT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = swig::check<Complex< double > * >(argv[1]) || swig::check<Complex< double > >(argv[1]);
      }
      if (_v) {
        return _wrap_ComplexD___add____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ComplexT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ComplexD___add____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ComplexD.__add__", 
    "    Complex< double > ComplexD.__add__(double const &scalar)\n"
    "    Complex< double > ComplexD.__add__(Complex< double > const &complex)\n");
  
  return Qnil;
}

#-(*args, self) ⇒ Object 



5258
5259
5260
5261
5262
5263
5264
5265
5266
5267
5268
5269
5270
5271
5272
5273
5274
5275
5276
5277
5278
5279
5280
5281
5282
5283
5284
5285
5286
5287
5288
5289
5290
5291
5292
5293
5294
5295
5296
5297
5298
5299
5300
5301
5302
5303
5304
5305
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 5258

SWIGINTERN VALUE _wrap_ComplexD___sub__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ComplexT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = swig::check<Complex< double > * >(argv[1]) || swig::check<Complex< double > >(argv[1]);
      }
      if (_v) {
        return _wrap_ComplexD___sub____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ComplexT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ComplexD___sub____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ComplexD.__sub__", 
    "    Complex< double > ComplexD.__sub__(double const &scalar)\n"
    "    Complex< double > ComplexD.__sub__(Complex< double > const &complex)\n");
  
  return Qnil;
}

#-@(*args) ⇒ Object 



5096
5097
5098
5099
5100
5101
5102
5103
5104
5105
5106
5107
5108
5109
5110
5111
5112
5113
5114
5115
5116
5117
5118
5119
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 5096

SWIGINTERN VALUE
_wrap_ComplexD___neg__(int argc, VALUE *argv, VALUE self) {
  Complex< double > *arg1 = (Complex< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Complex< 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_ComplexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Complex< double > const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< Complex< double > * >(argp1);
  result = ((Complex< double > const *)arg1)->operator -();
  {
    vresult = swig::from(result);
  }
  return vresult;
fail:
  return Qnil;
}

#/(*args, self) ⇒ Object Also known as: fdiv 



5446
5447
5448
5449
5450
5451
5452
5453
5454
5455
5456
5457
5458
5459
5460
5461
5462
5463
5464
5465
5466
5467
5468
5469
5470
5471
5472
5473
5474
5475
5476
5477
5478
5479
5480
5481
5482
5483
5484
5485
5486
5487
5488
5489
5490
5491
5492
5493
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 5446

SWIGINTERN VALUE _wrap_ComplexD___div__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ComplexT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = swig::check<Complex< double > * >(argv[1]) || swig::check<Complex< double > >(argv[1]);
      }
      if (_v) {
        return _wrap_ComplexD___div____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ComplexT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ComplexD___div____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ComplexD.__div__", 
    "    Complex< double > ComplexD.__div__(double const &scalar)\n"
    "    Complex< double > ComplexD.__div__(Complex< double > const &complex)\n");
  
  return Qnil;
}

#==(*args) ⇒ Object 



4874
4875
4876
4877
4878
4879
4880
4881
4882
4883
4884
4885
4886
4887
4888
4889
4890
4891
4892
4893
4894
4895
4896
4897
4898
4899
4900
4901
4902
4903
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 4874

SWIGINTERN VALUE
_wrap_ComplexD___eq__(int argc, VALUE *argv, VALUE self) {
  Complex< double > *arg1 = (Complex< double > *) 0 ;
  Complex< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Complex< double > temp2 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ComplexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Complex< double > const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Complex< double > * >(argp1);
  {
    if((!SWIG_IsOK(swig::asptr(argv[0], &arg2)))
      && (!SWIG_IsOK(swig::asval(argv[0], (arg2 = &temp2))))){
      SWIG_exception(SWIG_TypeError, "in method 'operator ==', expecting type Complex< double >");
    }
  }
  result = (bool)((Complex< double > const *)arg1)->operator ==((Complex< double > const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#abs(*args) ⇒ Object Also known as: magnitude 



4694
4695
4696
4697
4698
4699
4700
4701
4702
4703
4704
4705
4706
4707
4708
4709
4710
4711
4712
4713
4714
4715
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 4694

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

#abs2(*args) ⇒ Object 



4661
4662
4663
4664
4665
4666
4667
4668
4669
4670
4671
4672
4673
4674
4675
4676
4677
4678
4679
4680
4681
4682
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 4661

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

#arg(*args) ⇒ Object Also known as: angle, phase 



4727
4728
4729
4730
4731
4732
4733
4734
4735
4736
4737
4738
4739
4740
4741
4742
4743
4744
4745
4746
4747
4748
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 4727

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

#conjugate(*args) ⇒ Object Also known as: conj 



4840
4841
4842
4843
4844
4845
4846
4847
4848
4849
4850
4851
4852
4853
4854
4855
4856
4857
4858
4859
4860
4861
4862
4863
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 4840

SWIGINTERN VALUE
_wrap_ComplexD_conjugate(int argc, VALUE *argv, VALUE self) {
  Complex< double > *arg1 = (Complex< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Complex< 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_ComplexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Complex< double > const *","conjugate", 1, self )); 
  }
  arg1 = reinterpret_cast< Complex< double > * >(argp1);
  result = ((Complex< double > const *)arg1)->conjugate();
  {
    vresult = swig::from(result);
  }
  return vresult;
fail:
  return Qnil;
}

#finite?(*args) ⇒ Object 



4628
4629
4630
4631
4632
4633
4634
4635
4636
4637
4638
4639
4640
4641
4642
4643
4644
4645
4646
4647
4648
4649
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 4628

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

#imaginary(*args) ⇒ Object Also known as: imag 



5905
5906
5907
5908
5909
5910
5911
5912
5913
5914
5915
5916
5917
5918
5919
5920
5921
5922
5923
5924
5925
5926
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 5905

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

#imaginary=(*args) ⇒ Object Also known as: imag= 



5862
5863
5864
5865
5866
5867
5868
5869
5870
5871
5872
5873
5874
5875
5876
5877
5878
5879
5880
5881
5882
5883
5884
5885
5886
5887
5888
5889
5890
5891
5892
5893
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 5862

SWIGINTERN VALUE
_wrap_ComplexD_imaginarye___(int argc, VALUE *argv, VALUE self) {
  Complex< double > *arg1 = (Complex< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ComplexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Complex< double > *","set_imaginary", 1, self )); 
  }
  arg1 = reinterpret_cast< Complex< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_imaginary", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  result = (double)Complex_Sl_double_Sg__set_imaginary(arg1,(double const &)*arg2);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#infinite?(*args) ⇒ Object 



4595
4596
4597
4598
4599
4600
4601
4602
4603
4604
4605
4606
4607
4608
4609
4610
4611
4612
4613
4614
4615
4616
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 4595

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

#power(*args) ⇒ Object Also known as: ** 



4760
4761
4762
4763
4764
4765
4766
4767
4768
4769
4770
4771
4772
4773
4774
4775
4776
4777
4778
4779
4780
4781
4782
4783
4784
4785
4786
4787
4788
4789
4790
4791
4792
4793
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 4760

SWIGINTERN VALUE
_wrap_ComplexD_power(int argc, VALUE *argv, VALUE self) {
  Complex< double > *arg1 = (Complex< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  Complex< double > result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ComplexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Complex< double > const *","power", 1, self )); 
  }
  arg1 = reinterpret_cast< Complex< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","power", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  result = ((Complex< double > const *)arg1)->power((double const &)*arg2);
  {
    vresult = swig::from(result);
  }
  return vresult;
fail:
  return Qnil;
}

#real(*args) ⇒ Object 



5829
5830
5831
5832
5833
5834
5835
5836
5837
5838
5839
5840
5841
5842
5843
5844
5845
5846
5847
5848
5849
5850
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 5829

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

#real=(*args) ⇒ Object 



5786
5787
5788
5789
5790
5791
5792
5793
5794
5795
5796
5797
5798
5799
5800
5801
5802
5803
5804
5805
5806
5807
5808
5809
5810
5811
5812
5813
5814
5815
5816
5817
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 5786

SWIGINTERN VALUE
_wrap_ComplexD_reale___(int argc, VALUE *argv, VALUE self) {
  Complex< double > *arg1 = (Complex< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ComplexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Complex< double > *","set_real", 1, self )); 
  }
  arg1 = reinterpret_cast< Complex< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_real", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  result = (double)Complex_Sl_double_Sg__set_real(arg1,(double const &)*arg2);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#sqrt(*args) ⇒ Object 



4805
4806
4807
4808
4809
4810
4811
4812
4813
4814
4815
4816
4817
4818
4819
4820
4821
4822
4823
4824
4825
4826
4827
4828
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 4805

SWIGINTERN VALUE
_wrap_ComplexD_sqrt(int argc, VALUE *argv, VALUE self) {
  Complex< double > *arg1 = (Complex< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Complex< 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_ComplexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Complex< double > const *","sqrt", 1, self )); 
  }
  arg1 = reinterpret_cast< Complex< double > * >(argp1);
  result = ((Complex< double > const *)arg1)->sqrt();
  {
    vresult = swig::from(result);
  }
  return vresult;
fail:
  return Qnil;
}

#to_s(*args) ⇒ Object 



5938
5939
5940
5941
5942
5943
5944
5945
5946
5947
5948
5949
5950
5951
5952
5953
5954
5955
5956
5957
5958
5959
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 5938

SWIGINTERN VALUE
_wrap_ComplexD___str__(int argc, VALUE *argv, VALUE self) {
  Complex< double > *arg1 = (Complex< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string 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_ComplexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Complex< double > const *","__str__", 1, self )); 
  }
  arg1 = reinterpret_cast< Complex< double > * >(argp1);
  result = Complex_Sl_double_Sg____str__((Complex< double > const *)arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}