Class: GPS_PVT::SylphideMath::MatrixComplexD

Inherits:
((swig_class *) SWIGTYPE_p_Matrix_FrozenT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t->clientdata)->klass
  • 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::MatrixComplexD class

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(*args, self) ⇒ Object 



21244
21245
21246
21247
21248
21249
21250
21251
21252
21253
21254
21255
21256
21257
21258
21259
21260
21261
21262
21263
21264
21265
21266
21267
21268
21269
21270
21271
21272
21273
21274
21275
21276
21277
21278
21279
21280
21281
21282
21283
21284
21285
21286
21287
21288
21289
21290
21291
21292
21293
21294
21295
21296
21297
21298
21299
21300
21301
21302
21303
21304
21305
21306
21307
21308
21309
21310
21311
21312
21313
21314
21315
21316
21317
21318
21319
21320
21321
21322
21323
21324
21325
21326
21327
21328
21329
21330
21331
21332
21333
21334
21335
21336
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 21244

SWIGINTERN VALUE _wrap_new_MatrixComplexD(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    {
      _v = rb_block_given_p() ? 0 : 1;
      
      
      
    }
    if (_v) {
      return _wrap_new_MatrixComplexD__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_MatrixComplexD__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_ComplexT_double_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_MatrixComplexD__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = rb_block_given_p() ? 0 : 1;
          
          
          
        }
        if (_v) {
          return _wrap_new_MatrixComplexD__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "MatrixComplexD.new", 
    "    MatrixComplexD.new(unsigned int const &rows, unsigned int const &columns, void const *replacer)\n"
    "    MatrixComplexD.new(unsigned int const &rows, unsigned int const &columns)\n"
    "    MatrixComplexD.new(unsigned int const &rows, unsigned int const &columns, Complex< double > const *serialized)\n"
    "    MatrixComplexD.new(void const *replacer)\n");
  
  return Qnil;
}

Class Method Details

.I(*args) ⇒ Object 



21454
21455
21456
21457
21458
21459
21460
21461
21462
21463
21464
21465
21466
21467
21468
21469
21470
21471
21472
21473
21474
21475
21476
21477
21478
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 21454

SWIGINTERN VALUE
_wrap_MatrixComplexD_I(int argc, VALUE *argv, VALUE self) {
  unsigned int *arg1 = 0 ;
  unsigned int temp1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  SwigValueWrapper< Matrix< Complex< double >,Array2D_Dense< Complex< double > > > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned int","Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__getI", 1, argv[0] ));
  } 
  temp1 = static_cast< unsigned int >(val1);
  arg1 = &temp1;
  raise_if_lt_zero_after_asval(*arg1);
  result = Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__getI((unsigned int const &)*arg1);
  vresult = SWIG_NewPointerObj((new Matrix< Complex< double >,Array2D_Dense< Complex< double > > >(static_cast< const Matrix< Complex< double >,Array2D_Dense< Complex< double > > >& >(result))), SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

.scalar(*args) ⇒ Object 



21410
21411
21412
21413
21414
21415
21416
21417
21418
21419
21420
21421
21422
21423
21424
21425
21426
21427
21428
21429
21430
21431
21432
21433
21434
21435
21436
21437
21438
21439
21440
21441
21442
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 21410

SWIGINTERN VALUE
_wrap_MatrixComplexD_scalar(int argc, VALUE *argv, VALUE self) {
  unsigned int *arg1 = 0 ;
  Complex< double > *arg2 = 0 ;
  unsigned int temp1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  Complex< double > temp2 ;
  SwigValueWrapper< Matrix< Complex< double >,Array2D_Dense< Complex< double > > > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned int","Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__getScalar", 1, argv[0] ));
  } 
  temp1 = static_cast< unsigned int >(val1);
  arg1 = &temp1;
  {
    if((!SWIG_IsOK(swig::asptr(argv[1], &arg2)))
      && (!SWIG_IsOK(swig::asval(argv[1], (arg2 = &temp2))))){
      SWIG_exception(SWIG_TypeError, "in method 'Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__getScalar', expecting type Complex< double >");
    }
  }
  raise_if_lt_zero_after_asval(*arg1);
  result = Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__getScalar((unsigned int const &)*arg1,(Complex< double > const &)*arg2);
  vresult = SWIG_NewPointerObj((new Matrix< Complex< double >,Array2D_Dense< Complex< double > > >(static_cast< const Matrix< Complex< double >,Array2D_Dense< Complex< double > > >& >(result))), SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

Instance Method Details

#[]=(*args) ⇒ Object 



21347
21348
21349
21350
21351
21352
21353
21354
21355
21356
21357
21358
21359
21360
21361
21362
21363
21364
21365
21366
21367
21368
21369
21370
21371
21372
21373
21374
21375
21376
21377
21378
21379
21380
21381
21382
21383
21384
21385
21386
21387
21388
21389
21390
21391
21392
21393
21394
21395
21396
21397
21398
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 21347

SWIGINTERN VALUE
_wrap_MatrixComplexD___setitem__(int argc, VALUE *argv, VALUE self) {
  Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *arg1 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *) 0 ;
  unsigned int *arg2 = 0 ;
  unsigned int *arg3 = 0 ;
  Complex< double > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int temp2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int temp3 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Complex< double > temp4 ;
  Complex< double > *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *","__setitem__", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix< Complex< double >,Array2D_Dense< Complex< double > > > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","__setitem__", 2, argv[0] ));
  } 
  temp2 = static_cast< unsigned int >(val2);
  arg2 = &temp2;
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","__setitem__", 3, argv[1] ));
  } 
  temp3 = static_cast< unsigned int >(val3);
  arg3 = &temp3;
  {
    if((!SWIG_IsOK(swig::asptr(argv[2], &arg4)))
      && (!SWIG_IsOK(swig::asval(argv[2], (arg4 = &temp4))))){
      SWIG_exception(SWIG_TypeError, "in method '__setitem__', expecting type Complex< double >");
    }
  }
  raise_if_lt_zero_after_asval(*arg2);
  raise_if_lt_zero_after_asval(*arg3);
  result = (Complex< double > *) &Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg____setitem__(arg1,(unsigned int const &)*arg2,(unsigned int const &)*arg3,(Complex< double > const &)*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ComplexT_double_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#map!(*args, self) ⇒ Object Also known as: collect!, map_with_index!, collect_with_index! 



21990
21991
21992
21993
21994
21995
21996
21997
21998
21999
22000
22001
22002
22003
22004
22005
22006
22007
22008
22009
22010
22011
22012
22013
22014
22015
22016
22017
22018
22019
22020
22021
22022
22023
22024
22025
22026
22027
22028
22029
22030
22031
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 21990

SWIGINTERN VALUE _wrap_MatrixComplexD_mapN___(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MatrixComplexD_mapN_____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = (MatrixUtil::sym2each_which(argv[1]) != MatrixUtil::EACH_UNKNOWN);
      }
      if (_v) {
        return _wrap_MatrixComplexD_mapN_____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "map!", 
    "    void map!(Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *self_p, void (*each_func)(Complex< double > const &,Complex< double > *,unsigned int const &,unsigned int const &), MatrixUtil::each_which_t const each_which)\n"
    "    void map!(Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *self_p, void (*each_func)(Complex< double > const &,Complex< double > *,unsigned int const &,unsigned int const &))\n");
  
  return Qnil;
}

#replace!(*args, self) ⇒ Object 



21802
21803
21804
21805
21806
21807
21808
21809
21810
21811
21812
21813
21814
21815
21816
21817
21818
21819
21820
21821
21822
21823
21824
21825
21826
21827
21828
21829
21830
21831
21832
21833
21834
21835
21836
21837
21838
21839
21840
21841
21842
21843
21844
21845
21846
21847
21848
21849
21850
21851
21852
21853
21854
21855
21856
21857
21858
21859
21860
21861
21862
21863
21864
21865
21866
21867
21868
21869
21870
21871
21872
21873
21874
21875
21876
21877
21878
21879
21880
21881
21882
21883
21884
21885
21886
21887
21888
21889
21890
21891
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 21802

SWIGINTERN VALUE _wrap_MatrixComplexD_replaceN___(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MatrixComplexD_replaceN_____SWIG_4(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Matrix_FrozenT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewFilterT_MatrixViewBaseT_t_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MatrixComplexD_replaceN_____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Matrix_FrozenT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MatrixComplexD_replaceN_____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ComplexT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MatrixComplexD_replaceN_____SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = rb_block_given_p() ? 0 : 1;
        
        
        
      }
      if (_v) {
        return _wrap_MatrixComplexD_replaceN_____SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "replace!", 
    "    void replace!(Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *self_p, Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewBase< > > const &matrix)\n"
    "    void replace!(Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *self_p, Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewFilter< MatrixViewBase< > > > const &matrix)\n"
    "    void replace!(Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *self_p, void const *replacer)\n"
    "    void replace!(Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *self_p)\n"
    "    void replace!(Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *self_p, Complex< double > const *serialized)\n");
  
  return Qnil;
}

#resize!(*args) ⇒ Object 



22042
22043
22044
22045
22046
22047
22048
22049
22050
22051
22052
22053
22054
22055
22056
22057
22058
22059
22060
22061
22062
22063
22064
22065
22066
22067
22068
22069
22070
22071
22072
22073
22074
22075
22076
22077
22078
22079
22080
22081
22082
22083
22084
22085
22086
22087
22088
22089
22090
22091
22092
22093
22094
22095
22096
22097
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 22042

SWIGINTERN VALUE
_wrap_MatrixComplexD_resizeN___(int argc, VALUE *argv, VALUE self) {
  Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *arg1 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *) 0 ;
  unsigned int *arg2 = (unsigned int *) 0 ;
  unsigned int *arg3 = (unsigned int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int temp2 ;
  unsigned int temp3 ;
  Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *result = 0 ;
  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_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *","resize", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix< Complex< double >,Array2D_Dense< Complex< double > > > * >(argp1);
  {
    if(SWIG_IsOK(SWIG_AsVal_unsigned_SS_int (argv[0], &temp2))){
      raise_if_lt_zero_after_asval(temp2);
      
      arg2 = &temp2;
    }
    
    else if(NIL_P(argv[0])){
      arg2 = NULL;
    }
    
    else{
      SWIG_exception(SWIG_TypeError, "unsigned int is expected");
    }
  }
  {
    if(SWIG_IsOK(SWIG_AsVal_unsigned_SS_int (argv[1], &temp3))){
      raise_if_lt_zero_after_asval(temp3);
      
      arg3 = &temp3;
    }
    
    else if(NIL_P(argv[1])){
      arg3 = NULL;
    }
    
    else{
      SWIG_exception(SWIG_TypeError, "unsigned int is expected");
    }
  }
  result = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *) &Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__resize(arg1,(unsigned int const *)arg2,(unsigned int const *)arg3);
  vresult = self;
  return vresult;
fail:
  return Qnil;
}

#swap_columns!(*args) ⇒ Object 



21550
21551
21552
21553
21554
21555
21556
21557
21558
21559
21560
21561
21562
21563
21564
21565
21566
21567
21568
21569
21570
21571
21572
21573
21574
21575
21576
21577
21578
21579
21580
21581
21582
21583
21584
21585
21586
21587
21588
21589
21590
21591
21592
21593
21594
21595
21596
21597
21598
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 21550

SWIGINTERN VALUE
_wrap_MatrixComplexD_swap_columnsN___(int argc, VALUE *argv, VALUE self) {
  Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *arg1 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *) 0 ;
  Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *arg2 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *) 0 ;
  unsigned int *arg3 = 0 ;
  unsigned int *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int temp3 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int temp4 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  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_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *","swap_columns", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix< Complex< double >,Array2D_Dense< Complex< double > > > * >(argp1);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[0], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","swap_columns", 3, argv[0] ));
  } 
  temp3 = static_cast< unsigned int >(val3);
  arg3 = &temp3;
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[1], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","swap_columns", 4, argv[1] ));
  } 
  temp4 = static_cast< unsigned int >(val4);
  arg4 = &temp4;
  raise_if_lt_zero_after_asval(*arg3);
  raise_if_lt_zero_after_asval(*arg4);
  try {
    Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__swap_columns(arg1,arg2,(unsigned int const &)*arg3,(unsigned int const &)*arg4);
  } catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  vresult = self;
  return vresult;
fail:
  return Qnil;
}

#swap_rows!(*args) ⇒ Object 



21490
21491
21492
21493
21494
21495
21496
21497
21498
21499
21500
21501
21502
21503
21504
21505
21506
21507
21508
21509
21510
21511
21512
21513
21514
21515
21516
21517
21518
21519
21520
21521
21522
21523
21524
21525
21526
21527
21528
21529
21530
21531
21532
21533
21534
21535
21536
21537
21538
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 21490

SWIGINTERN VALUE
_wrap_MatrixComplexD_swap_rowsN___(int argc, VALUE *argv, VALUE self) {
  Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *arg1 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *) 0 ;
  Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *arg2 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *) 0 ;
  unsigned int *arg3 = 0 ;
  unsigned int *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int temp3 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int temp4 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  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_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *","swap_rows", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix< Complex< double >,Array2D_Dense< Complex< double > > > * >(argp1);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[0], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","swap_rows", 3, argv[0] ));
  } 
  temp3 = static_cast< unsigned int >(val3);
  arg3 = &temp3;
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[1], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","swap_rows", 4, argv[1] ));
  } 
  temp4 = static_cast< unsigned int >(val4);
  arg4 = &temp4;
  raise_if_lt_zero_after_asval(*arg3);
  raise_if_lt_zero_after_asval(*arg4);
  try {
    Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__swap_rows(arg1,arg2,(unsigned int const &)*arg3,(unsigned int const &)*arg4);
  } catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  vresult = self;
  return vresult;
fail:
  return Qnil;
}