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 



21057
21058
21059
21060
21061
21062
21063
21064
21065
21066
21067
21068
21069
21070
21071
21072
21073
21074
21075
21076
21077
21078
21079
21080
21081
21082
21083
21084
21085
21086
21087
21088
21089
21090
21091
21092
21093
21094
21095
21096
21097
21098
21099
21100
21101
21102
21103
21104
21105
21106
21107
21108
21109
21110
21111
21112
21113
21114
21115
21116
21117
21118
21119
21120
21121
21122
21123
21124
21125
21126
21127
21128
21129
21130
21131
21132
21133
21134
21135
21136
21137
21138
21139
21140
21141
21142
21143
21144
21145
21146
21147
21148
21149
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 21057

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

call-seq:

I(unsigned int const & size) -> MatrixComplexD

A class method.



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
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 21267

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

call-seq:

scalar(unsigned int const & size, ComplexD scalar) -> MatrixComplexD

A class method.



21223
21224
21225
21226
21227
21228
21229
21230
21231
21232
21233
21234
21235
21236
21237
21238
21239
21240
21241
21242
21243
21244
21245
21246
21247
21248
21249
21250
21251
21252
21253
21254
21255
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 21223

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

call-seq:

[]=(row, column, value) -> ComplexD

Element setter/slicing.



21160
21161
21162
21163
21164
21165
21166
21167
21168
21169
21170
21171
21172
21173
21174
21175
21176
21177
21178
21179
21180
21181
21182
21183
21184
21185
21186
21187
21188
21189
21190
21191
21192
21193
21194
21195
21196
21197
21198
21199
21200
21201
21202
21203
21204
21205
21206
21207
21208
21209
21210
21211
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 21160

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!

call-seq:

map!(MatrixUtil::each_which_t const each_which=MatrixUtil::EACH_ALL)
map!

An instance method.



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
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 21803

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

call-seq:

replace!(matrix)
replace!(matrix)
replace!(replacer=nil)
replace!
replace!(serialized)

Replace all or a portion of the MatrixComplexD.



21615
21616
21617
21618
21619
21620
21621
21622
21623
21624
21625
21626
21627
21628
21629
21630
21631
21632
21633
21634
21635
21636
21637
21638
21639
21640
21641
21642
21643
21644
21645
21646
21647
21648
21649
21650
21651
21652
21653
21654
21655
21656
21657
21658
21659
21660
21661
21662
21663
21664
21665
21666
21667
21668
21669
21670
21671
21672
21673
21674
21675
21676
21677
21678
21679
21680
21681
21682
21683
21684
21685
21686
21687
21688
21689
21690
21691
21692
21693
21694
21695
21696
21697
21698
21699
21700
21701
21702
21703
21704
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 21615

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

call-seq:

resize(r_p, c_p) -> MatrixComplexD

Resize the size of the MatrixComplexD.



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
21892
21893
21894
21895
21896
21897
21898
21899
21900
21901
21902
21903
21904
21905
21906
21907
21908
21909
21910
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 21855

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 = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#swap_columns!(*args) ⇒ Object

call-seq:

swap_columns(unsigned int const & c1, unsigned int const & c2)

An instance method.



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
21399
21400
21401
21402
21403
21404
21405
21406
21407
21408
21409
21410
21411
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 21363

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

call-seq:

swap_rows(unsigned int const & r1, unsigned int const & r2)

An instance method.



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
21337
21338
21339
21340
21341
21342
21343
21344
21345
21346
21347
21348
21349
21350
21351
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 21303

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;
}