gps_pvt 0.2.1 → 0.3.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1862,8 +1862,9 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
1862
1862
  #define SWIGTYPE_p_f_r_q_const__double_p_double_r_q_const__unsigned_int_r_q_const__unsigned_int__void swig_types[12]
1863
1863
  #define SWIGTYPE_p_self_t swig_types[13]
1864
1864
  #define SWIGTYPE_p_swig__GC_VALUE swig_types[14]
1865
- static swig_type_info *swig_types[16];
1866
- static swig_module_info swig_module = {swig_types, 15, 0, 0, 0, 0};
1865
+ #define SWIGTYPE_p_unsigned_int swig_types[15]
1866
+ static swig_type_info *swig_types[17];
1867
+ static swig_module_info swig_module = {swig_types, 16, 0, 0, 0, 0};
1867
1868
  #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1868
1869
  #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1869
1870
 
@@ -3202,6 +3203,16 @@ SWIG_AsVal_unsigned_SS_int (VALUE obj, unsigned int *val)
3202
3203
  return res;
3203
3204
  }
3204
3205
 
3206
+
3207
+ inline bool is_lt_zero_after_asval(const unsigned int &i){
3208
+ return ((sizeof(unsigned int) == sizeof(unsigned long)) && ((UINT_MAX >> 1) <= i));
3209
+ }
3210
+ void raise_if_lt_zero_after_asval(const unsigned int &i){
3211
+ if(is_lt_zero_after_asval(i)){
3212
+ SWIG_exception(SWIG_ValueError, "Expected positive value.");
3213
+ }
3214
+ }
3215
+
3205
3216
  SWIGINTERN double Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg____getitem__(Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *self,unsigned int const &row,unsigned int const &column){
3206
3217
  return (self)->operator()(row, column);
3207
3218
  }
@@ -3615,13 +3626,10 @@ SWIGINTERN Matrix< double,Array2D_Dense< double > > *new_Matrix_Sl_double_Sc_Arr
3615
3626
  MatrixUtil::replace(res, replacer);
3616
3627
  return new Matrix<double, Array2D_Dense< double >, MatrixViewBase< >>(res);
3617
3628
  }else if(value && rb_respond_to(*value, id_r) && rb_respond_to(*value, id_c)){
3618
- /* "unsigned" is remove because SWIG_AsVal(unsigned int)
3619
- * can not detect less than zero in Windows Ruby devkit.
3620
- */
3621
- int r, c;
3629
+ unsigned int r, c;
3622
3630
  VALUE v_r(rb_funcall(*value, id_r, 0, 0)), v_c(rb_funcall(*value, id_c, 0, 0));
3623
- if(!SWIG_IsOK(SWIG_AsVal_int (v_r, &r)) || (r < 0)
3624
- || !SWIG_IsOK(SWIG_AsVal_int (v_c, &c)) || (c < 0)){
3631
+ if(!SWIG_IsOK(SWIG_AsVal_unsigned_SS_int (v_r, &r)) || is_lt_zero_after_asval(r)
3632
+ || !SWIG_IsOK(SWIG_AsVal_unsigned_SS_int (v_c, &c)) || is_lt_zero_after_asval(c)){
3625
3633
  throw std::runtime_error(
3626
3634
  std::string("Unexpected length [")
3627
3635
  .append(inspect_str(v_r)).append(", ")
@@ -3645,27 +3653,39 @@ SWIGINTERN Matrix< double,Array2D_Dense< double > > Matrix_Sl_double_Sc_Array2D_
3645
3653
  return Matrix<double, Array2D_Dense<double> >(
3646
3654
  Matrix_Frozen<double, Array2D_Dense< double >, MatrixViewBase< >>::getI(size));
3647
3655
  }
3648
- SWIGINTERN Matrix< double,Array2D_Dense< double > >::self_t &Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__replace_Sl_T_Sc_Array2D_Dense_Sl_T_Sg__Sc_MatViewBase_Sg___SWIG_1(Matrix< double,Array2D_Dense< double > > *self,Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const &matrix){
3649
- return self->replace(matrix);
3656
+ SWIGINTERN void Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__swap_rows(Matrix< double,Array2D_Dense< double > > *self,Matrix< double,Array2D_Dense< double > >::self_t *self_p,unsigned int const &r1,unsigned int const &r2){
3657
+ self->swapRows(r1, r2);
3658
+ }
3659
+ SWIGINTERN void Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__swap_columns(Matrix< double,Array2D_Dense< double > > *self,Matrix< double,Array2D_Dense< double > >::self_t *self_p,unsigned int const &c1,unsigned int const &c2){
3660
+ self->swapColumns(c1, c2);
3650
3661
  }
3651
- SWIGINTERN Matrix< double,Array2D_Dense< double > >::self_t &Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__replace_Sl_T_Sc_Array2D_Dense_Sl_T_Sg__Sc_MatView_f_Sg___SWIG_2(Matrix< double,Array2D_Dense< double > > *self,Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const &matrix){
3652
- return self->replace(matrix);
3662
+ SWIGINTERN void Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__replace_Sl_T_Sc_Array2D_Dense_Sl_T_Sg__Sc_MatViewBase_Sg___SWIG_1(Matrix< double,Array2D_Dense< double > > *self,Matrix< double,Array2D_Dense< double > >::self_t *self_p,Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const &matrix){
3663
+ self->replace(matrix);
3653
3664
  }
3654
- SWIGINTERN Matrix< double,Array2D_Dense< double > >::self_t &Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__replace__SWIG_3(Matrix< double,Array2D_Dense< double > > *self,void const *replacer=NULL){
3665
+ SWIGINTERN void Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__replace_Sl_T_Sc_Array2D_Dense_Sl_T_Sg__Sc_MatView_f_Sg___SWIG_2(Matrix< double,Array2D_Dense< double > > *self,Matrix< double,Array2D_Dense< double > >::self_t *self_p,Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const &matrix){
3666
+ self->replace(matrix);
3667
+ }
3668
+ SWIGINTERN void Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__replace__SWIG_3(Matrix< double,Array2D_Dense< double > > *self,Matrix< double,Array2D_Dense< double > >::self_t *self_p,void const *replacer=NULL){
3655
3669
  if(!MatrixUtil::replace(*self, replacer)){
3656
3670
  throw std::runtime_error("Unsupported replacement");
3657
3671
  }
3658
- return *self;
3659
3672
  }
3660
- SWIGINTERN Matrix< double,Array2D_Dense< double > >::self_t &Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__replace__SWIG_5(Matrix< double,Array2D_Dense< double > > *self,double const *serialized){
3673
+ SWIGINTERN void Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__replace__SWIG_5(Matrix< double,Array2D_Dense< double > > *self,Matrix< double,Array2D_Dense< double > >::self_t *self_p,double const *serialized){
3661
3674
  if(!MatrixUtil::replace(*self, serialized)){
3662
3675
  throw std::runtime_error("Unsupported replacement");
3663
3676
  }
3664
- return *self;
3665
3677
  }
3666
- SWIGINTERN Matrix< double,Array2D_Dense< double > >::self_t &Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__map_bang__SWIG_0(Matrix< double,Array2D_Dense< double > > *self,void (*each_func)(double const &,double *,unsigned int const &,unsigned int const &),MatrixUtil::each_which_t const &each_which=MatrixUtil::EACH_ALL){
3678
+ SWIGINTERN void Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__map_bang__SWIG_0(Matrix< double,Array2D_Dense< double > > *self,Matrix< double,Array2D_Dense< double > >::self_t *self_p,void (*each_func)(double const &,double *,unsigned int const &,unsigned int const &),MatrixUtil::each_which_t const &each_which=MatrixUtil::EACH_ALL){
3667
3679
  MatrixUtil::each(*self, each_func, each_which, self);
3668
- return *self;
3680
+ }
3681
+ SWIGINTERN Matrix< double,Array2D_Dense< double > > &Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__resize(Matrix< double,Array2D_Dense< double > > *self,unsigned int const *r_p,unsigned int const *c_p){
3682
+ unsigned int r(r_p ? *r_p : self->rows()), c(c_p ? *c_p : self->columns());
3683
+ Matrix<double, Array2D_Dense<double > > mat_new(r, c);
3684
+ unsigned int r_min(r), c_min(c);
3685
+ if(r_min > self->rows()){r_min = self->rows();}
3686
+ if(c_min > self->columns()){c_min = self->columns();}
3687
+ mat_new.partial(r_min, c_min).replace(self->partial(r_min, c_min), false);
3688
+ return (*(self) = mat_new);
3669
3689
  }
3670
3690
  SWIGINTERN Complex< double > Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sc_MatViewBase_Sg____getitem__(Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatViewBase > const *self,unsigned int const &row,unsigned int const &column){
3671
3691
  return (self)->operator()(row, column);
@@ -4080,13 +4100,10 @@ SWIGINTERN Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *new_M
4080
4100
  MatrixUtil::replace(res, replacer);
4081
4101
  return new Matrix<Complex< double >, Array2D_Dense< Complex< double > >, MatrixViewBase< >>(res);
4082
4102
  }else if(value && rb_respond_to(*value, id_r) && rb_respond_to(*value, id_c)){
4083
- /* "unsigned" is remove because SWIG_AsVal(unsigned int)
4084
- * can not detect less than zero in Windows Ruby devkit.
4085
- */
4086
- int r, c;
4103
+ unsigned int r, c;
4087
4104
  VALUE v_r(rb_funcall(*value, id_r, 0, 0)), v_c(rb_funcall(*value, id_c, 0, 0));
4088
- if(!SWIG_IsOK(SWIG_AsVal_int (v_r, &r)) || (r < 0)
4089
- || !SWIG_IsOK(SWIG_AsVal_int (v_c, &c)) || (c < 0)){
4105
+ if(!SWIG_IsOK(SWIG_AsVal_unsigned_SS_int (v_r, &r)) || is_lt_zero_after_asval(r)
4106
+ || !SWIG_IsOK(SWIG_AsVal_unsigned_SS_int (v_c, &c)) || is_lt_zero_after_asval(c)){
4090
4107
  throw std::runtime_error(
4091
4108
  std::string("Unexpected length [")
4092
4109
  .append(inspect_str(v_r)).append(", ")
@@ -4110,27 +4127,39 @@ SWIGINTERN Matrix< Complex< double >,Array2D_Dense< Complex< double > > > Matrix
4110
4127
  return Matrix<Complex< double >, Array2D_Dense<Complex< double >> >(
4111
4128
  Matrix_Frozen<Complex< double >, Array2D_Dense< Complex< double > >, MatrixViewBase< >>::getI(size));
4112
4129
  }
4113
- SWIGINTERN Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t &Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__replace_Sl_T_Sc_Array2D_Dense_Sl_T_Sg__Sc_MatViewBase_Sg___SWIG_1(Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *self,Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewBase< > > const &matrix){
4114
- return self->replace(matrix);
4130
+ SWIGINTERN void Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__swap_rows(Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *self,Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *self_p,unsigned int const &r1,unsigned int const &r2){
4131
+ self->swapRows(r1, r2);
4132
+ }
4133
+ SWIGINTERN void Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__swap_columns(Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *self,Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *self_p,unsigned int const &c1,unsigned int const &c2){
4134
+ self->swapColumns(c1, c2);
4115
4135
  }
4116
- SWIGINTERN Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t &Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__replace_Sl_T_Sc_Array2D_Dense_Sl_T_Sg__Sc_MatView_f_Sg___SWIG_2(Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *self,Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewFilter< MatrixViewBase< > > > const &matrix){
4117
- return self->replace(matrix);
4136
+ SWIGINTERN void Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__replace_Sl_T_Sc_Array2D_Dense_Sl_T_Sg__Sc_MatViewBase_Sg___SWIG_1(Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *self,Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *self_p,Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewBase< > > const &matrix){
4137
+ self->replace(matrix);
4118
4138
  }
4119
- SWIGINTERN Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t &Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__replace__SWIG_3(Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *self,void const *replacer=NULL){
4139
+ SWIGINTERN void Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__replace_Sl_T_Sc_Array2D_Dense_Sl_T_Sg__Sc_MatView_f_Sg___SWIG_2(Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *self,Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *self_p,Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewFilter< MatrixViewBase< > > > const &matrix){
4140
+ self->replace(matrix);
4141
+ }
4142
+ SWIGINTERN void Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__replace__SWIG_3(Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *self,Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *self_p,void const *replacer=NULL){
4120
4143
  if(!MatrixUtil::replace(*self, replacer)){
4121
4144
  throw std::runtime_error("Unsupported replacement");
4122
4145
  }
4123
- return *self;
4124
4146
  }
4125
- SWIGINTERN Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t &Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__replace__SWIG_5(Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *self,Complex< double > const *serialized){
4147
+ SWIGINTERN void Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__replace__SWIG_5(Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *self,Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *self_p,Complex< double > const *serialized){
4126
4148
  if(!MatrixUtil::replace(*self, serialized)){
4127
4149
  throw std::runtime_error("Unsupported replacement");
4128
4150
  }
4129
- return *self;
4130
4151
  }
4131
- SWIGINTERN Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t &Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__map_bang__SWIG_0(Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *self,void (*each_func)(Complex< double > const &,Complex< double > *,unsigned int const &,unsigned int const &),MatrixUtil::each_which_t const &each_which=MatrixUtil::EACH_ALL){
4152
+ SWIGINTERN void Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__map_bang__SWIG_0(Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *self,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=MatrixUtil::EACH_ALL){
4132
4153
  MatrixUtil::each(*self, each_func, each_which, self);
4133
- return *self;
4154
+ }
4155
+ SWIGINTERN Matrix< Complex< double >,Array2D_Dense< Complex< double > > > &Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__resize(Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *self,unsigned int const *r_p,unsigned int const *c_p){
4156
+ unsigned int r(r_p ? *r_p : self->rows()), c(c_p ? *c_p : self->columns());
4157
+ Matrix<Complex<double>, Array2D_Dense<Complex<double> > > mat_new(r, c);
4158
+ unsigned int r_min(r), c_min(c);
4159
+ if(r_min > self->rows()){r_min = self->rows();}
4160
+ if(c_min > self->columns()){c_min = self->columns();}
4161
+ mat_new.partial(r_min, c_min).replace(self->partial(r_min, c_min), false);
4162
+ return (*(self) = mat_new);
4134
4163
  }
4135
4164
  static swig_class SwigClassGC_VALUE;
4136
4165
 
@@ -6771,6 +6800,8 @@ _wrap_Matrix_FrozenD___getitem__(int argc, VALUE *argv, VALUE self) {
6771
6800
  }
6772
6801
  temp3 = static_cast< unsigned int >(val3);
6773
6802
  arg3 = &temp3;
6803
+ raise_if_lt_zero_after_asval(*arg2);
6804
+ raise_if_lt_zero_after_asval(*arg3);
6774
6805
  {
6775
6806
  try {
6776
6807
  result = (double)Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg____getitem__((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1,(unsigned int const &)*arg2,(unsigned int const &)*arg3);
@@ -6897,6 +6928,10 @@ _wrap_Matrix_FrozenD_circular__SWIG_0(int argc, VALUE *argv, VALUE self) {
6897
6928
  }
6898
6929
  temp5 = static_cast< unsigned int >(val5);
6899
6930
  arg5 = &temp5;
6931
+ raise_if_lt_zero_after_asval(*arg2);
6932
+ raise_if_lt_zero_after_asval(*arg3);
6933
+ raise_if_lt_zero_after_asval(*arg4);
6934
+ raise_if_lt_zero_after_asval(*arg5);
6900
6935
  {
6901
6936
  try {
6902
6937
  result = Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__circular__SWIG_0((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1,(unsigned int const &)*arg2,(unsigned int const &)*arg3,(unsigned int const &)*arg4,(unsigned int const &)*arg5);
@@ -6950,6 +6985,8 @@ _wrap_Matrix_FrozenD_circular__SWIG_1(int argc, VALUE *argv, VALUE self) {
6950
6985
  }
6951
6986
  temp3 = static_cast< unsigned int >(val3);
6952
6987
  arg3 = &temp3;
6988
+ raise_if_lt_zero_after_asval(*arg2);
6989
+ raise_if_lt_zero_after_asval(*arg3);
6953
6990
  {
6954
6991
  try {
6955
6992
  result = Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__circular__SWIG_1((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1,(unsigned int const &)*arg2,(unsigned int const &)*arg3);
@@ -9045,6 +9082,10 @@ _wrap_Matrix_FrozenD_partial(int argc, VALUE *argv, VALUE self) {
9045
9082
  }
9046
9083
  temp5 = static_cast< unsigned int >(val5);
9047
9084
  arg5 = &temp5;
9085
+ raise_if_lt_zero_after_asval(*arg2);
9086
+ raise_if_lt_zero_after_asval(*arg3);
9087
+ raise_if_lt_zero_after_asval(*arg4);
9088
+ raise_if_lt_zero_after_asval(*arg5);
9048
9089
  {
9049
9090
  try {
9050
9091
  result = Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__partial((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1,(unsigned int const &)*arg2,(unsigned int const &)*arg3,(unsigned int const &)*arg4,(unsigned int const &)*arg5);
@@ -9097,6 +9138,7 @@ _wrap_Matrix_FrozenD_row_vector(int argc, VALUE *argv, VALUE self) {
9097
9138
  }
9098
9139
  temp2 = static_cast< unsigned int >(val2);
9099
9140
  arg2 = &temp2;
9141
+ raise_if_lt_zero_after_asval(*arg2);
9100
9142
  {
9101
9143
  try {
9102
9144
  result = Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__row_vector((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1,(unsigned int const &)*arg2);
@@ -9149,6 +9191,7 @@ _wrap_Matrix_FrozenD_column_vector(int argc, VALUE *argv, VALUE self) {
9149
9191
  }
9150
9192
  temp2 = static_cast< unsigned int >(val2);
9151
9193
  arg2 = &temp2;
9194
+ raise_if_lt_zero_after_asval(*arg2);
9152
9195
  {
9153
9196
  try {
9154
9197
  result = Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__column_vector((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1,(unsigned int const &)*arg2);
@@ -9796,6 +9839,8 @@ _wrap_Matrix_FrozenD_f___getitem__(int argc, VALUE *argv, VALUE self) {
9796
9839
  }
9797
9840
  temp3 = static_cast< unsigned int >(val3);
9798
9841
  arg3 = &temp3;
9842
+ raise_if_lt_zero_after_asval(*arg2);
9843
+ raise_if_lt_zero_after_asval(*arg3);
9799
9844
  {
9800
9845
  try {
9801
9846
  result = (double)Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatView_f_Sg____getitem__((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const *)arg1,(unsigned int const &)*arg2,(unsigned int const &)*arg3);
@@ -9922,6 +9967,10 @@ _wrap_Matrix_FrozenD_f_circular__SWIG_0(int argc, VALUE *argv, VALUE self) {
9922
9967
  }
9923
9968
  temp5 = static_cast< unsigned int >(val5);
9924
9969
  arg5 = &temp5;
9970
+ raise_if_lt_zero_after_asval(*arg2);
9971
+ raise_if_lt_zero_after_asval(*arg3);
9972
+ raise_if_lt_zero_after_asval(*arg4);
9973
+ raise_if_lt_zero_after_asval(*arg5);
9925
9974
  {
9926
9975
  try {
9927
9976
  result = Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatView_f_Sg__circular__SWIG_0((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const *)arg1,(unsigned int const &)*arg2,(unsigned int const &)*arg3,(unsigned int const &)*arg4,(unsigned int const &)*arg5);
@@ -9975,6 +10024,8 @@ _wrap_Matrix_FrozenD_f_circular__SWIG_1(int argc, VALUE *argv, VALUE self) {
9975
10024
  }
9976
10025
  temp3 = static_cast< unsigned int >(val3);
9977
10026
  arg3 = &temp3;
10027
+ raise_if_lt_zero_after_asval(*arg2);
10028
+ raise_if_lt_zero_after_asval(*arg3);
9978
10029
  {
9979
10030
  try {
9980
10031
  result = Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatView_f_Sg__circular__SWIG_1((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const *)arg1,(unsigned int const &)*arg2,(unsigned int const &)*arg3);
@@ -12070,6 +12121,10 @@ _wrap_Matrix_FrozenD_f_partial(int argc, VALUE *argv, VALUE self) {
12070
12121
  }
12071
12122
  temp5 = static_cast< unsigned int >(val5);
12072
12123
  arg5 = &temp5;
12124
+ raise_if_lt_zero_after_asval(*arg2);
12125
+ raise_if_lt_zero_after_asval(*arg3);
12126
+ raise_if_lt_zero_after_asval(*arg4);
12127
+ raise_if_lt_zero_after_asval(*arg5);
12073
12128
  {
12074
12129
  try {
12075
12130
  result = Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatView_f_Sg__partial((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const *)arg1,(unsigned int const &)*arg2,(unsigned int const &)*arg3,(unsigned int const &)*arg4,(unsigned int const &)*arg5);
@@ -12122,6 +12177,7 @@ _wrap_Matrix_FrozenD_f_row_vector(int argc, VALUE *argv, VALUE self) {
12122
12177
  }
12123
12178
  temp2 = static_cast< unsigned int >(val2);
12124
12179
  arg2 = &temp2;
12180
+ raise_if_lt_zero_after_asval(*arg2);
12125
12181
  {
12126
12182
  try {
12127
12183
  result = Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatView_f_Sg__row_vector((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const *)arg1,(unsigned int const &)*arg2);
@@ -12174,6 +12230,7 @@ _wrap_Matrix_FrozenD_f_column_vector(int argc, VALUE *argv, VALUE self) {
12174
12230
  }
12175
12231
  temp2 = static_cast< unsigned int >(val2);
12176
12232
  arg2 = &temp2;
12233
+ raise_if_lt_zero_after_asval(*arg2);
12177
12234
  {
12178
12235
  try {
12179
12236
  result = Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatView_f_Sg__column_vector((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const *)arg1,(unsigned int const &)*arg2);
@@ -12263,130 +12320,6 @@ free_Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatView_f_Sg_(voi
12263
12320
  */
12264
12321
  static swig_class SwigClassMatrixD;
12265
12322
 
12266
- /*
12267
- Document-method: GPS_PVT::SylphideMath::MatrixD.swap_rows
12268
-
12269
- call-seq:
12270
- swap_rows(unsigned int const & row1, unsigned int const & row2) -> MatrixD
12271
-
12272
- An instance method.
12273
-
12274
- */
12275
- SWIGINTERN VALUE
12276
- _wrap_MatrixD_swap_rowsN___(int argc, VALUE *argv, VALUE self) {
12277
- Matrix< double,Array2D_Dense< double > > *arg1 = (Matrix< double,Array2D_Dense< double > > *) 0 ;
12278
- unsigned int *arg2 = 0 ;
12279
- unsigned int *arg3 = 0 ;
12280
- void *argp1 = 0 ;
12281
- int res1 = 0 ;
12282
- unsigned int temp2 ;
12283
- unsigned int val2 ;
12284
- int ecode2 = 0 ;
12285
- unsigned int temp3 ;
12286
- unsigned int val3 ;
12287
- int ecode3 = 0 ;
12288
- Matrix< double,Array2D_Dense< double > >::self_t *result = 0 ;
12289
- VALUE vresult = Qnil;
12290
-
12291
- if ((argc < 2) || (argc > 2)) {
12292
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
12293
- }
12294
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 | 0 );
12295
- if (!SWIG_IsOK(res1)) {
12296
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< double,Array2D_Dense< double > > *","swapRows", 1, self ));
12297
- }
12298
- arg1 = reinterpret_cast< Matrix< double,Array2D_Dense< double > > * >(argp1);
12299
- ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
12300
- if (!SWIG_IsOK(ecode2)) {
12301
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","swapRows", 2, argv[0] ));
12302
- }
12303
- temp2 = static_cast< unsigned int >(val2);
12304
- arg2 = &temp2;
12305
- ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
12306
- if (!SWIG_IsOK(ecode3)) {
12307
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","swapRows", 3, argv[1] ));
12308
- }
12309
- temp3 = static_cast< unsigned int >(val3);
12310
- arg3 = &temp3;
12311
- {
12312
- try {
12313
- result = (Matrix< double,Array2D_Dense< double > >::self_t *) &(arg1)->swapRows((unsigned int const &)*arg2,(unsigned int const &)*arg3);
12314
- } catch (const native_exception &e) {
12315
- e.regenerate();
12316
- SWIG_fail;
12317
- } catch (const std::exception& e) {
12318
- SWIG_exception_fail(SWIG_RuntimeError, e.what());
12319
- }
12320
- }
12321
- vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 | 0 );
12322
- return vresult;
12323
- fail:
12324
- return Qnil;
12325
- }
12326
-
12327
-
12328
- /*
12329
- Document-method: GPS_PVT::SylphideMath::MatrixD.swap_columns
12330
-
12331
- call-seq:
12332
- swap_columns(unsigned int const & column1, unsigned int const & column2) -> MatrixD
12333
-
12334
- An instance method.
12335
-
12336
- */
12337
- SWIGINTERN VALUE
12338
- _wrap_MatrixD_swap_columnsN___(int argc, VALUE *argv, VALUE self) {
12339
- Matrix< double,Array2D_Dense< double > > *arg1 = (Matrix< double,Array2D_Dense< double > > *) 0 ;
12340
- unsigned int *arg2 = 0 ;
12341
- unsigned int *arg3 = 0 ;
12342
- void *argp1 = 0 ;
12343
- int res1 = 0 ;
12344
- unsigned int temp2 ;
12345
- unsigned int val2 ;
12346
- int ecode2 = 0 ;
12347
- unsigned int temp3 ;
12348
- unsigned int val3 ;
12349
- int ecode3 = 0 ;
12350
- Matrix< double,Array2D_Dense< double > >::self_t *result = 0 ;
12351
- VALUE vresult = Qnil;
12352
-
12353
- if ((argc < 2) || (argc > 2)) {
12354
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
12355
- }
12356
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 | 0 );
12357
- if (!SWIG_IsOK(res1)) {
12358
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< double,Array2D_Dense< double > > *","swapColumns", 1, self ));
12359
- }
12360
- arg1 = reinterpret_cast< Matrix< double,Array2D_Dense< double > > * >(argp1);
12361
- ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
12362
- if (!SWIG_IsOK(ecode2)) {
12363
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","swapColumns", 2, argv[0] ));
12364
- }
12365
- temp2 = static_cast< unsigned int >(val2);
12366
- arg2 = &temp2;
12367
- ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
12368
- if (!SWIG_IsOK(ecode3)) {
12369
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","swapColumns", 3, argv[1] ));
12370
- }
12371
- temp3 = static_cast< unsigned int >(val3);
12372
- arg3 = &temp3;
12373
- {
12374
- try {
12375
- result = (Matrix< double,Array2D_Dense< double > >::self_t *) &(arg1)->swapColumns((unsigned int const &)*arg2,(unsigned int const &)*arg3);
12376
- } catch (const native_exception &e) {
12377
- e.regenerate();
12378
- SWIG_fail;
12379
- } catch (const std::exception& e) {
12380
- SWIG_exception_fail(SWIG_RuntimeError, e.what());
12381
- }
12382
- }
12383
- vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 | 0 );
12384
- return vresult;
12385
- fail:
12386
- return Qnil;
12387
- }
12388
-
12389
-
12390
12323
  /*
12391
12324
  Document-method: GPS_PVT::SylphideMath::MatrixD.new
12392
12325
 
@@ -12430,6 +12363,8 @@ _wrap_new_MatrixD__SWIG_0(int argc, VALUE *argv, VALUE self) {
12430
12363
  {
12431
12364
  arg3 = &argv[2];
12432
12365
  }
12366
+ raise_if_lt_zero_after_asval(*arg1);
12367
+ raise_if_lt_zero_after_asval(*arg2);
12433
12368
  {
12434
12369
  try {
12435
12370
  result = (Matrix< double,Array2D_Dense< double > > *)new_Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg___SWIG_0((unsigned int const &)*arg1,(unsigned int const &)*arg2,(void const *)arg3);
@@ -12474,6 +12409,8 @@ _wrap_new_MatrixD__SWIG_1(int argc, VALUE *argv, VALUE self) {
12474
12409
  }
12475
12410
  temp2 = static_cast< unsigned int >(val2);
12476
12411
  arg2 = &temp2;
12412
+ raise_if_lt_zero_after_asval(*arg1);
12413
+ raise_if_lt_zero_after_asval(*arg2);
12477
12414
  {
12478
12415
  try {
12479
12416
  result = (Matrix< double,Array2D_Dense< double > > *)new_Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg___SWIG_0((unsigned int const &)*arg1,(unsigned int const &)*arg2);
@@ -12526,6 +12463,8 @@ _wrap_new_MatrixD__SWIG_2(int argc, VALUE *argv, VALUE self) {
12526
12463
  SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double const *","Matrix<(double,Array2D_Dense<(double)>)>", 3, argv[2] ));
12527
12464
  }
12528
12465
  arg3 = reinterpret_cast< double * >(argp3);
12466
+ raise_if_lt_zero_after_asval(*arg1);
12467
+ raise_if_lt_zero_after_asval(*arg2);
12529
12468
  {
12530
12469
  try {
12531
12470
  result = (Matrix< double,Array2D_Dense< double > > *)new_Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg___SWIG_2((unsigned int const &)*arg1,(unsigned int const &)*arg2,(double const *)arg3);
@@ -12735,6 +12674,8 @@ _wrap_MatrixD___setitem__(int argc, VALUE *argv, VALUE self) {
12735
12674
  }
12736
12675
  temp4 = static_cast< double >(val4);
12737
12676
  arg4 = &temp4;
12677
+ raise_if_lt_zero_after_asval(*arg2);
12678
+ raise_if_lt_zero_after_asval(*arg3);
12738
12679
  {
12739
12680
  try {
12740
12681
  result = (double *) &Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg____setitem__(arg1,(unsigned int const &)*arg2,(unsigned int const &)*arg3,(double const &)*arg4);
@@ -12789,6 +12730,7 @@ _wrap_MatrixD_scalar(int argc, VALUE *argv, VALUE self) {
12789
12730
  }
12790
12731
  temp2 = static_cast< double >(val2);
12791
12732
  arg2 = &temp2;
12733
+ raise_if_lt_zero_after_asval(*arg1);
12792
12734
  {
12793
12735
  try {
12794
12736
  result = Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__getScalar((unsigned int const &)*arg1,(double const &)*arg2);
@@ -12833,6 +12775,7 @@ _wrap_MatrixD_I(int argc, VALUE *argv, VALUE self) {
12833
12775
  }
12834
12776
  temp1 = static_cast< unsigned int >(val1);
12835
12777
  arg1 = &temp1;
12778
+ raise_if_lt_zero_after_asval(*arg1);
12836
12779
  {
12837
12780
  try {
12838
12781
  result = Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__getI((unsigned int const &)*arg1);
@@ -12851,47 +12794,56 @@ fail:
12851
12794
 
12852
12795
 
12853
12796
  /*
12854
- Document-method: GPS_PVT::SylphideMath::MatrixD.replace!
12797
+ Document-method: GPS_PVT::SylphideMath::MatrixD.swap_rows
12855
12798
 
12856
12799
  call-seq:
12857
- replace!(matrix) -> MatrixD
12858
- replace!(matrix) -> MatrixD
12859
- replace!(replacer=nil) -> MatrixD
12860
- replace! -> MatrixD
12861
- replace!(serialized) -> MatrixD
12800
+ swap_rows(unsigned int const & r1, unsigned int const & r2)
12801
+
12802
+ An instance method.
12862
12803
 
12863
- Replace all or a portion of the MatrixD.
12864
12804
  */
12865
12805
  SWIGINTERN VALUE
12866
- _wrap_MatrixD_replaceN_____SWIG_1(int argc, VALUE *argv, VALUE self) {
12806
+ _wrap_MatrixD_swap_rowsN___(int argc, VALUE *argv, VALUE self) {
12867
12807
  Matrix< double,Array2D_Dense< double > > *arg1 = (Matrix< double,Array2D_Dense< double > > *) 0 ;
12868
- Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > *arg2 = 0 ;
12808
+ Matrix< double,Array2D_Dense< double > >::self_t *arg2 = (Matrix< double,Array2D_Dense< double > >::self_t *) 0 ;
12809
+ unsigned int *arg3 = 0 ;
12810
+ unsigned int *arg4 = 0 ;
12869
12811
  void *argp1 = 0 ;
12870
12812
  int res1 = 0 ;
12871
- void *argp2 ;
12872
- int res2 = 0 ;
12873
- Matrix< double,Array2D_Dense< double > >::self_t *result = 0 ;
12813
+ unsigned int temp3 ;
12814
+ unsigned int val3 ;
12815
+ int ecode3 = 0 ;
12816
+ unsigned int temp4 ;
12817
+ unsigned int val4 ;
12818
+ int ecode4 = 0 ;
12874
12819
  VALUE vresult = Qnil;
12875
12820
 
12876
- if ((argc < 1) || (argc > 1)) {
12877
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12821
+
12822
+ if ((argc < 2) || (argc > 2)) {
12823
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
12878
12824
  }
12879
12825
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 | 0 );
12880
12826
  if (!SWIG_IsOK(res1)) {
12881
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< double,Array2D_Dense< double > > *","replace<(T,Array2D_Dense<(T)>,MatViewBase)>", 1, self ));
12827
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< double,Array2D_Dense< double > > *","swap_rows", 1, self ));
12882
12828
  }
12883
12829
  arg1 = reinterpret_cast< Matrix< double,Array2D_Dense< double > > * >(argp1);
12884
- res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 );
12885
- if (!SWIG_IsOK(res2)) {
12886
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const &","replace<(T,Array2D_Dense<(T)>,MatViewBase)>", 2, argv[0] ));
12887
- }
12888
- if (!argp2) {
12889
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const &","replace<(T,Array2D_Dense<(T)>,MatViewBase)>", 2, argv[0]));
12890
- }
12891
- arg2 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > * >(argp2);
12830
+ ecode3 = SWIG_AsVal_unsigned_SS_int(argv[0], &val3);
12831
+ if (!SWIG_IsOK(ecode3)) {
12832
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","swap_rows", 3, argv[0] ));
12833
+ }
12834
+ temp3 = static_cast< unsigned int >(val3);
12835
+ arg3 = &temp3;
12836
+ ecode4 = SWIG_AsVal_unsigned_SS_int(argv[1], &val4);
12837
+ if (!SWIG_IsOK(ecode4)) {
12838
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","swap_rows", 4, argv[1] ));
12839
+ }
12840
+ temp4 = static_cast< unsigned int >(val4);
12841
+ arg4 = &temp4;
12842
+ raise_if_lt_zero_after_asval(*arg3);
12843
+ raise_if_lt_zero_after_asval(*arg4);
12892
12844
  {
12893
12845
  try {
12894
- result = (Matrix< double,Array2D_Dense< double > >::self_t *) &Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__replace_Sl_T_Sc_Array2D_Dense_Sl_T_Sg__Sc_MatViewBase_Sg___SWIG_1(arg1,(Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const &)*arg2);
12846
+ Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__swap_rows(arg1,arg2,(unsigned int const &)*arg3,(unsigned int const &)*arg4);
12895
12847
  } catch (const native_exception &e) {
12896
12848
  e.regenerate();
12897
12849
  SWIG_fail;
@@ -12906,36 +12858,57 @@ fail:
12906
12858
  }
12907
12859
 
12908
12860
 
12861
+ /*
12862
+ Document-method: GPS_PVT::SylphideMath::MatrixD.swap_columns
12863
+
12864
+ call-seq:
12865
+ swap_columns(unsigned int const & c1, unsigned int const & c2)
12866
+
12867
+ An instance method.
12868
+
12869
+ */
12909
12870
  SWIGINTERN VALUE
12910
- _wrap_MatrixD_replaceN_____SWIG_2(int argc, VALUE *argv, VALUE self) {
12871
+ _wrap_MatrixD_swap_columnsN___(int argc, VALUE *argv, VALUE self) {
12911
12872
  Matrix< double,Array2D_Dense< double > > *arg1 = (Matrix< double,Array2D_Dense< double > > *) 0 ;
12912
- Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > *arg2 = 0 ;
12873
+ Matrix< double,Array2D_Dense< double > >::self_t *arg2 = (Matrix< double,Array2D_Dense< double > >::self_t *) 0 ;
12874
+ unsigned int *arg3 = 0 ;
12875
+ unsigned int *arg4 = 0 ;
12913
12876
  void *argp1 = 0 ;
12914
12877
  int res1 = 0 ;
12915
- void *argp2 ;
12916
- int res2 = 0 ;
12917
- Matrix< double,Array2D_Dense< double > >::self_t *result = 0 ;
12878
+ unsigned int temp3 ;
12879
+ unsigned int val3 ;
12880
+ int ecode3 = 0 ;
12881
+ unsigned int temp4 ;
12882
+ unsigned int val4 ;
12883
+ int ecode4 = 0 ;
12918
12884
  VALUE vresult = Qnil;
12919
12885
 
12920
- if ((argc < 1) || (argc > 1)) {
12921
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12886
+
12887
+ if ((argc < 2) || (argc > 2)) {
12888
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
12922
12889
  }
12923
12890
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 | 0 );
12924
12891
  if (!SWIG_IsOK(res1)) {
12925
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< double,Array2D_Dense< double > > *","replace<(T,Array2D_Dense<(T)>,MatView_f)>", 1, self ));
12892
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< double,Array2D_Dense< double > > *","swap_columns", 1, self ));
12926
12893
  }
12927
12894
  arg1 = reinterpret_cast< Matrix< double,Array2D_Dense< double > > * >(argp1);
12928
- res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewFilterT_MatrixViewBaseT_t_t_t, 0 );
12929
- if (!SWIG_IsOK(res2)) {
12930
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const &","replace<(T,Array2D_Dense<(T)>,MatView_f)>", 2, argv[0] ));
12931
- }
12932
- if (!argp2) {
12933
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const &","replace<(T,Array2D_Dense<(T)>,MatView_f)>", 2, argv[0]));
12934
- }
12935
- arg2 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > * >(argp2);
12895
+ ecode3 = SWIG_AsVal_unsigned_SS_int(argv[0], &val3);
12896
+ if (!SWIG_IsOK(ecode3)) {
12897
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","swap_columns", 3, argv[0] ));
12898
+ }
12899
+ temp3 = static_cast< unsigned int >(val3);
12900
+ arg3 = &temp3;
12901
+ ecode4 = SWIG_AsVal_unsigned_SS_int(argv[1], &val4);
12902
+ if (!SWIG_IsOK(ecode4)) {
12903
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","swap_columns", 4, argv[1] ));
12904
+ }
12905
+ temp4 = static_cast< unsigned int >(val4);
12906
+ arg4 = &temp4;
12907
+ raise_if_lt_zero_after_asval(*arg3);
12908
+ raise_if_lt_zero_after_asval(*arg4);
12936
12909
  {
12937
12910
  try {
12938
- result = (Matrix< double,Array2D_Dense< double > >::self_t *) &Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__replace_Sl_T_Sc_Array2D_Dense_Sl_T_Sg__Sc_MatView_f_Sg___SWIG_2(arg1,(Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const &)*arg2);
12911
+ Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__swap_columns(arg1,arg2,(unsigned int const &)*arg3,(unsigned int const &)*arg4);
12939
12912
  } catch (const native_exception &e) {
12940
12913
  e.regenerate();
12941
12914
  SWIG_fail;
@@ -12950,29 +12923,49 @@ fail:
12950
12923
  }
12951
12924
 
12952
12925
 
12926
+ /*
12927
+ Document-method: GPS_PVT::SylphideMath::MatrixD.replace!
12928
+
12929
+ call-seq:
12930
+ replace!(matrix)
12931
+ replace!(matrix)
12932
+ replace!(replacer=nil)
12933
+ replace!
12934
+ replace!(serialized)
12935
+
12936
+ Replace all or a portion of the MatrixD.
12937
+ */
12953
12938
  SWIGINTERN VALUE
12954
- _wrap_MatrixD_replaceN_____SWIG_3(int argc, VALUE *argv, VALUE self) {
12939
+ _wrap_MatrixD_replaceN_____SWIG_1(int argc, VALUE *argv, VALUE self) {
12955
12940
  Matrix< double,Array2D_Dense< double > > *arg1 = (Matrix< double,Array2D_Dense< double > > *) 0 ;
12956
- void *arg2 = (void *) 0 ;
12941
+ Matrix< double,Array2D_Dense< double > >::self_t *arg2 = (Matrix< double,Array2D_Dense< double > >::self_t *) 0 ;
12942
+ Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > *arg3 = 0 ;
12957
12943
  void *argp1 = 0 ;
12958
12944
  int res1 = 0 ;
12959
- Matrix< double,Array2D_Dense< double > >::self_t *result = 0 ;
12945
+ void *argp3 ;
12946
+ int res3 = 0 ;
12960
12947
  VALUE vresult = Qnil;
12961
12948
 
12949
+
12962
12950
  if ((argc < 1) || (argc > 1)) {
12963
12951
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12964
12952
  }
12965
12953
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 | 0 );
12966
12954
  if (!SWIG_IsOK(res1)) {
12967
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< double,Array2D_Dense< double > > *","replace", 1, self ));
12955
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< double,Array2D_Dense< double > > *","replace<(T,Array2D_Dense<(T)>,MatViewBase)>", 1, self ));
12968
12956
  }
12969
12957
  arg1 = reinterpret_cast< Matrix< double,Array2D_Dense< double > > * >(argp1);
12970
- {
12971
- arg2 = &argv[0];
12958
+ res3 = SWIG_ConvertPtr(argv[0], &argp3, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 );
12959
+ if (!SWIG_IsOK(res3)) {
12960
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const &","replace<(T,Array2D_Dense<(T)>,MatViewBase)>", 3, argv[0] ));
12961
+ }
12962
+ if (!argp3) {
12963
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const &","replace<(T,Array2D_Dense<(T)>,MatViewBase)>", 3, argv[0]));
12972
12964
  }
12965
+ arg3 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > * >(argp3);
12973
12966
  {
12974
12967
  try {
12975
- result = (Matrix< double,Array2D_Dense< double > >::self_t *) &Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__replace__SWIG_3(arg1,(void const *)arg2);
12968
+ Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__replace_Sl_T_Sc_Array2D_Dense_Sl_T_Sg__Sc_MatViewBase_Sg___SWIG_1(arg1,arg2,(Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const &)*arg3);
12976
12969
  } catch (const native_exception &e) {
12977
12970
  e.regenerate();
12978
12971
  SWIG_fail;
@@ -12988,24 +12981,36 @@ fail:
12988
12981
 
12989
12982
 
12990
12983
  SWIGINTERN VALUE
12991
- _wrap_MatrixD_replaceN_____SWIG_4(int argc, VALUE *argv, VALUE self) {
12984
+ _wrap_MatrixD_replaceN_____SWIG_2(int argc, VALUE *argv, VALUE self) {
12992
12985
  Matrix< double,Array2D_Dense< double > > *arg1 = (Matrix< double,Array2D_Dense< double > > *) 0 ;
12986
+ Matrix< double,Array2D_Dense< double > >::self_t *arg2 = (Matrix< double,Array2D_Dense< double > >::self_t *) 0 ;
12987
+ Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > *arg3 = 0 ;
12993
12988
  void *argp1 = 0 ;
12994
12989
  int res1 = 0 ;
12995
- Matrix< double,Array2D_Dense< double > >::self_t *result = 0 ;
12990
+ void *argp3 ;
12991
+ int res3 = 0 ;
12996
12992
  VALUE vresult = Qnil;
12997
12993
 
12998
- if ((argc < 0) || (argc > 0)) {
12999
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12994
+
12995
+ if ((argc < 1) || (argc > 1)) {
12996
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13000
12997
  }
13001
12998
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 | 0 );
13002
12999
  if (!SWIG_IsOK(res1)) {
13003
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< double,Array2D_Dense< double > > *","replace", 1, self ));
13000
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< double,Array2D_Dense< double > > *","replace<(T,Array2D_Dense<(T)>,MatView_f)>", 1, self ));
13004
13001
  }
13005
13002
  arg1 = reinterpret_cast< Matrix< double,Array2D_Dense< double > > * >(argp1);
13003
+ res3 = SWIG_ConvertPtr(argv[0], &argp3, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewFilterT_MatrixViewBaseT_t_t_t, 0 );
13004
+ if (!SWIG_IsOK(res3)) {
13005
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const &","replace<(T,Array2D_Dense<(T)>,MatView_f)>", 3, argv[0] ));
13006
+ }
13007
+ if (!argp3) {
13008
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const &","replace<(T,Array2D_Dense<(T)>,MatView_f)>", 3, argv[0]));
13009
+ }
13010
+ arg3 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > * >(argp3);
13006
13011
  {
13007
13012
  try {
13008
- result = (Matrix< double,Array2D_Dense< double > >::self_t *) &Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__replace__SWIG_3(arg1);
13013
+ Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__replace_Sl_T_Sc_Array2D_Dense_Sl_T_Sg__Sc_MatView_f_Sg___SWIG_2(arg1,arg2,(Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const &)*arg3);
13009
13014
  } catch (const native_exception &e) {
13010
13015
  e.regenerate();
13011
13016
  SWIG_fail;
@@ -13021,16 +13026,15 @@ fail:
13021
13026
 
13022
13027
 
13023
13028
  SWIGINTERN VALUE
13024
- _wrap_MatrixD_replaceN_____SWIG_5(int argc, VALUE *argv, VALUE self) {
13029
+ _wrap_MatrixD_replaceN_____SWIG_3(int argc, VALUE *argv, VALUE self) {
13025
13030
  Matrix< double,Array2D_Dense< double > > *arg1 = (Matrix< double,Array2D_Dense< double > > *) 0 ;
13026
- double *arg2 = (double *) 0 ;
13031
+ Matrix< double,Array2D_Dense< double > >::self_t *arg2 = (Matrix< double,Array2D_Dense< double > >::self_t *) 0 ;
13032
+ void *arg3 = (void *) 0 ;
13027
13033
  void *argp1 = 0 ;
13028
13034
  int res1 = 0 ;
13029
- void *argp2 = 0 ;
13030
- int res2 = 0 ;
13031
- Matrix< double,Array2D_Dense< double > >::self_t *result = 0 ;
13032
13035
  VALUE vresult = Qnil;
13033
13036
 
13037
+
13034
13038
  if ((argc < 1) || (argc > 1)) {
13035
13039
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13036
13040
  }
@@ -13039,14 +13043,12 @@ _wrap_MatrixD_replaceN_____SWIG_5(int argc, VALUE *argv, VALUE self) {
13039
13043
  SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< double,Array2D_Dense< double > > *","replace", 1, self ));
13040
13044
  }
13041
13045
  arg1 = reinterpret_cast< Matrix< double,Array2D_Dense< double > > * >(argp1);
13042
- res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_double, 0 | 0 );
13043
- if (!SWIG_IsOK(res2)) {
13044
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const *","replace", 2, argv[0] ));
13046
+ {
13047
+ arg3 = &argv[0];
13045
13048
  }
13046
- arg2 = reinterpret_cast< double * >(argp2);
13047
13049
  {
13048
13050
  try {
13049
- result = (Matrix< double,Array2D_Dense< double > >::self_t *) &Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__replace__SWIG_5(arg1,(double const *)arg2);
13051
+ Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__replace__SWIG_3(arg1,arg2,(void const *)arg3);
13050
13052
  } catch (const native_exception &e) {
13051
13053
  e.regenerate();
13052
13054
  SWIG_fail;
@@ -13061,13 +13063,89 @@ fail:
13061
13063
  }
13062
13064
 
13063
13065
 
13064
- SWIGINTERN VALUE _wrap_MatrixD_replaceN___(int nargs, VALUE *args, VALUE self) {
13065
- int argc;
13066
- VALUE argv[3];
13067
- int ii;
13066
+ SWIGINTERN VALUE
13067
+ _wrap_MatrixD_replaceN_____SWIG_4(int argc, VALUE *argv, VALUE self) {
13068
+ Matrix< double,Array2D_Dense< double > > *arg1 = (Matrix< double,Array2D_Dense< double > > *) 0 ;
13069
+ Matrix< double,Array2D_Dense< double > >::self_t *arg2 = (Matrix< double,Array2D_Dense< double > >::self_t *) 0 ;
13070
+ void *argp1 = 0 ;
13071
+ int res1 = 0 ;
13072
+ VALUE vresult = Qnil;
13068
13073
 
13069
- argc = nargs + 1;
13070
- argv[0] = self;
13074
+
13075
+ if ((argc < 0) || (argc > 0)) {
13076
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13077
+ }
13078
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 | 0 );
13079
+ if (!SWIG_IsOK(res1)) {
13080
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< double,Array2D_Dense< double > > *","replace", 1, self ));
13081
+ }
13082
+ arg1 = reinterpret_cast< Matrix< double,Array2D_Dense< double > > * >(argp1);
13083
+ {
13084
+ try {
13085
+ Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__replace__SWIG_3(arg1,arg2);
13086
+ } catch (const native_exception &e) {
13087
+ e.regenerate();
13088
+ SWIG_fail;
13089
+ } catch (const std::exception& e) {
13090
+ SWIG_exception_fail(SWIG_RuntimeError, e.what());
13091
+ }
13092
+ }
13093
+ vresult = self;
13094
+ return vresult;
13095
+ fail:
13096
+ return Qnil;
13097
+ }
13098
+
13099
+
13100
+ SWIGINTERN VALUE
13101
+ _wrap_MatrixD_replaceN_____SWIG_5(int argc, VALUE *argv, VALUE self) {
13102
+ Matrix< double,Array2D_Dense< double > > *arg1 = (Matrix< double,Array2D_Dense< double > > *) 0 ;
13103
+ Matrix< double,Array2D_Dense< double > >::self_t *arg2 = (Matrix< double,Array2D_Dense< double > >::self_t *) 0 ;
13104
+ double *arg3 = (double *) 0 ;
13105
+ void *argp1 = 0 ;
13106
+ int res1 = 0 ;
13107
+ void *argp3 = 0 ;
13108
+ int res3 = 0 ;
13109
+ VALUE vresult = Qnil;
13110
+
13111
+
13112
+ if ((argc < 1) || (argc > 1)) {
13113
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13114
+ }
13115
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 | 0 );
13116
+ if (!SWIG_IsOK(res1)) {
13117
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< double,Array2D_Dense< double > > *","replace", 1, self ));
13118
+ }
13119
+ arg1 = reinterpret_cast< Matrix< double,Array2D_Dense< double > > * >(argp1);
13120
+ res3 = SWIG_ConvertPtr(argv[0], &argp3,SWIGTYPE_p_double, 0 | 0 );
13121
+ if (!SWIG_IsOK(res3)) {
13122
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double const *","replace", 3, argv[0] ));
13123
+ }
13124
+ arg3 = reinterpret_cast< double * >(argp3);
13125
+ {
13126
+ try {
13127
+ Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__replace__SWIG_5(arg1,arg2,(double const *)arg3);
13128
+ } catch (const native_exception &e) {
13129
+ e.regenerate();
13130
+ SWIG_fail;
13131
+ } catch (const std::exception& e) {
13132
+ SWIG_exception_fail(SWIG_RuntimeError, e.what());
13133
+ }
13134
+ }
13135
+ vresult = self;
13136
+ return vresult;
13137
+ fail:
13138
+ return Qnil;
13139
+ }
13140
+
13141
+
13142
+ SWIGINTERN VALUE _wrap_MatrixD_replaceN___(int nargs, VALUE *args, VALUE self) {
13143
+ int argc;
13144
+ VALUE argv[3];
13145
+ int ii;
13146
+
13147
+ argc = nargs + 1;
13148
+ argv[0] = self;
13071
13149
  if (argc > 3) SWIG_fail;
13072
13150
  for (ii = 1; (ii < argc); ++ii) {
13073
13151
  argv[ii] = args[ii-1];
@@ -13143,11 +13221,11 @@ SWIGINTERN VALUE _wrap_MatrixD_replaceN___(int nargs, VALUE *args, VALUE self) {
13143
13221
 
13144
13222
  fail:
13145
13223
  Ruby_Format_OverloadedError( argc, 3, "replace!",
13146
- " Matrix< double,Array2D_Dense< double > >::self_t replace!(Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const &matrix)\n"
13147
- " Matrix< double,Array2D_Dense< double > >::self_t replace!(Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const &matrix)\n"
13148
- " Matrix< double,Array2D_Dense< double > >::self_t replace!(void const *replacer)\n"
13149
- " Matrix< double,Array2D_Dense< double > >::self_t replace!()\n"
13150
- " Matrix< double,Array2D_Dense< double > >::self_t & replace!(double const *serialized)\n");
13224
+ " void replace!(Matrix< double,Array2D_Dense< double > >::self_t *self_p, Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const &matrix)\n"
13225
+ " void replace!(Matrix< double,Array2D_Dense< double > >::self_t *self_p, Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const &matrix)\n"
13226
+ " void replace!(Matrix< double,Array2D_Dense< double > >::self_t *self_p, void const *replacer)\n"
13227
+ " void replace!(Matrix< double,Array2D_Dense< double > >::self_t *self_p)\n"
13228
+ " void replace!(Matrix< double,Array2D_Dense< double > >::self_t *self_p, double const *serialized)\n");
13151
13229
 
13152
13230
  return Qnil;
13153
13231
  }
@@ -13157,8 +13235,8 @@ fail:
13157
13235
  Document-method: GPS_PVT::SylphideMath::MatrixD.map!
13158
13236
 
13159
13237
  call-seq:
13160
- map!(MatrixUtil::each_which_t const & each_which=MatrixUtil::EACH_ALL) -> MatrixD
13161
- map! -> MatrixD
13238
+ map!(MatrixUtil::each_which_t const & each_which=MatrixUtil::EACH_ALL)
13239
+ map!
13162
13240
 
13163
13241
  An instance method.
13164
13242
 
@@ -13166,18 +13244,19 @@ An instance method.
13166
13244
  SWIGINTERN VALUE
13167
13245
  _wrap_MatrixD_mapN_____SWIG_0(int argc, VALUE *argv, VALUE self) {
13168
13246
  Matrix< double,Array2D_Dense< double > > *arg1 = (Matrix< double,Array2D_Dense< double > > *) 0 ;
13169
- void (*arg2)(double const &,double *,unsigned int const &,unsigned int const &) = (void (*)(double const &,double *,unsigned int const &,unsigned int const &)) 0 ;
13170
- MatrixUtil::each_which_t *arg3 = 0 ;
13247
+ Matrix< double,Array2D_Dense< double > >::self_t *arg2 = (Matrix< double,Array2D_Dense< double > >::self_t *) 0 ;
13248
+ void (*arg3)(double const &,double *,unsigned int const &,unsigned int const &) = (void (*)(double const &,double *,unsigned int const &,unsigned int const &)) 0 ;
13249
+ MatrixUtil::each_which_t *arg4 = 0 ;
13171
13250
  void *argp1 = 0 ;
13172
13251
  int res1 = 0 ;
13173
- Matrix< double,Array2D_Dense< double > >::self_t *result = 0 ;
13174
13252
  VALUE vresult = Qnil;
13175
13253
 
13254
+
13176
13255
  {
13177
13256
  if(!rb_block_given_p()){
13178
13257
  return rb_enumeratorize(self, ID2SYM(rb_frame_callee()), argc, argv);
13179
13258
  }
13180
- arg2 = matrix_each((const double *)0);
13259
+ arg3 = matrix_each((const double *)0);
13181
13260
  }
13182
13261
  if ((argc < 1) || (argc > 1)) {
13183
13262
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
@@ -13189,14 +13268,14 @@ _wrap_MatrixD_mapN_____SWIG_0(int argc, VALUE *argv, VALUE self) {
13189
13268
  arg1 = reinterpret_cast< Matrix< double,Array2D_Dense< double > > * >(argp1);
13190
13269
  {
13191
13270
  try{
13192
- arg3 = &const_cast<typename MatrixUtil::each_which_t &>(MatrixUtil::sym2each_which(argv[0]));
13271
+ arg4 = &const_cast<typename MatrixUtil::each_which_t &>(MatrixUtil::sym2each_which(argv[0]));
13193
13272
  }catch(std::runtime_error &e){
13194
13273
  SWIG_exception(SWIG_TypeError, e.what());
13195
13274
  }
13196
13275
  }
13197
13276
  {
13198
13277
  try {
13199
- result = (Matrix< double,Array2D_Dense< double > >::self_t *) &Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__map_bang__SWIG_0(arg1,arg2,(MatrixUtil::each_which_t const &)*arg3);
13278
+ Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__map_bang__SWIG_0(arg1,arg2,arg3,(MatrixUtil::each_which_t const &)*arg4);
13200
13279
  } catch (const native_exception &e) {
13201
13280
  e.regenerate();
13202
13281
  SWIG_fail;
@@ -13214,17 +13293,18 @@ fail:
13214
13293
  SWIGINTERN VALUE
13215
13294
  _wrap_MatrixD_mapN_____SWIG_1(int argc, VALUE *argv, VALUE self) {
13216
13295
  Matrix< double,Array2D_Dense< double > > *arg1 = (Matrix< double,Array2D_Dense< double > > *) 0 ;
13217
- void (*arg2)(double const &,double *,unsigned int const &,unsigned int const &) = (void (*)(double const &,double *,unsigned int const &,unsigned int const &)) 0 ;
13296
+ Matrix< double,Array2D_Dense< double > >::self_t *arg2 = (Matrix< double,Array2D_Dense< double > >::self_t *) 0 ;
13297
+ void (*arg3)(double const &,double *,unsigned int const &,unsigned int const &) = (void (*)(double const &,double *,unsigned int const &,unsigned int const &)) 0 ;
13218
13298
  void *argp1 = 0 ;
13219
13299
  int res1 = 0 ;
13220
- Matrix< double,Array2D_Dense< double > >::self_t *result = 0 ;
13221
13300
  VALUE vresult = Qnil;
13222
13301
 
13302
+
13223
13303
  {
13224
13304
  if(!rb_block_given_p()){
13225
13305
  return rb_enumeratorize(self, ID2SYM(rb_frame_callee()), argc, argv);
13226
13306
  }
13227
- arg2 = matrix_each((const double *)0);
13307
+ arg3 = matrix_each((const double *)0);
13228
13308
  }
13229
13309
  if ((argc < 0) || (argc > 0)) {
13230
13310
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
@@ -13236,7 +13316,7 @@ _wrap_MatrixD_mapN_____SWIG_1(int argc, VALUE *argv, VALUE self) {
13236
13316
  arg1 = reinterpret_cast< Matrix< double,Array2D_Dense< double > > * >(argp1);
13237
13317
  {
13238
13318
  try {
13239
- result = (Matrix< double,Array2D_Dense< double > >::self_t *) &Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__map_bang__SWIG_0(arg1,arg2);
13319
+ Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__map_bang__SWIG_0(arg1,arg2,arg3);
13240
13320
  } catch (const native_exception &e) {
13241
13321
  e.regenerate();
13242
13322
  SWIG_fail;
@@ -13288,13 +13368,88 @@ SWIGINTERN VALUE _wrap_MatrixD_mapN___(int nargs, VALUE *args, VALUE self) {
13288
13368
 
13289
13369
  fail:
13290
13370
  Ruby_Format_OverloadedError( argc, 3, "map!",
13291
- " Matrix< double,Array2D_Dense< double > >::self_t map!(void (*each_func)(double const &,double *,unsigned int const &,unsigned int const &), MatrixUtil::each_which_t const &each_which)\n"
13292
- " Matrix< double,Array2D_Dense< double > >::self_t & map!(void (*each_func)(double const &,double *,unsigned int const &,unsigned int const &))\n");
13371
+ " void map!(Matrix< double,Array2D_Dense< double > >::self_t *self_p, void (*each_func)(double const &,double *,unsigned int const &,unsigned int const &), MatrixUtil::each_which_t const &each_which)\n"
13372
+ " void map!(Matrix< double,Array2D_Dense< double > >::self_t *self_p, void (*each_func)(double const &,double *,unsigned int const &,unsigned int const &))\n");
13293
13373
 
13294
13374
  return Qnil;
13295
13375
  }
13296
13376
 
13297
13377
 
13378
+ /*
13379
+ Document-method: GPS_PVT::SylphideMath::MatrixD.resize
13380
+
13381
+ call-seq:
13382
+ resize(r_p, c_p) -> MatrixD
13383
+
13384
+ Resize the size of the MatrixD.
13385
+ */
13386
+ SWIGINTERN VALUE
13387
+ _wrap_MatrixD_resizeN___(int argc, VALUE *argv, VALUE self) {
13388
+ Matrix< double,Array2D_Dense< double > > *arg1 = (Matrix< double,Array2D_Dense< double > > *) 0 ;
13389
+ unsigned int *arg2 = (unsigned int *) 0 ;
13390
+ unsigned int *arg3 = (unsigned int *) 0 ;
13391
+ void *argp1 = 0 ;
13392
+ int res1 = 0 ;
13393
+ unsigned int temp2 ;
13394
+ unsigned int temp3 ;
13395
+ Matrix< double,Array2D_Dense< double > > *result = 0 ;
13396
+ VALUE vresult = Qnil;
13397
+
13398
+ if ((argc < 2) || (argc > 2)) {
13399
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
13400
+ }
13401
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 | 0 );
13402
+ if (!SWIG_IsOK(res1)) {
13403
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< double,Array2D_Dense< double > > *","resize", 1, self ));
13404
+ }
13405
+ arg1 = reinterpret_cast< Matrix< double,Array2D_Dense< double > > * >(argp1);
13406
+ {
13407
+ if(SWIG_IsOK(SWIG_AsVal_unsigned_SS_int (argv[0], &temp2))){
13408
+ raise_if_lt_zero_after_asval(temp2);
13409
+
13410
+ arg2 = &temp2;
13411
+ }
13412
+
13413
+ else if(NIL_P(argv[0])){
13414
+ arg2 = NULL;
13415
+ }
13416
+
13417
+ else{
13418
+ SWIG_exception(SWIG_TypeError, "unsigned int is expected");
13419
+ }
13420
+ }
13421
+ {
13422
+ if(SWIG_IsOK(SWIG_AsVal_unsigned_SS_int (argv[1], &temp3))){
13423
+ raise_if_lt_zero_after_asval(temp3);
13424
+
13425
+ arg3 = &temp3;
13426
+ }
13427
+
13428
+ else if(NIL_P(argv[1])){
13429
+ arg3 = NULL;
13430
+ }
13431
+
13432
+ else{
13433
+ SWIG_exception(SWIG_TypeError, "unsigned int is expected");
13434
+ }
13435
+ }
13436
+ {
13437
+ try {
13438
+ result = (Matrix< double,Array2D_Dense< double > > *) &Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg__resize(arg1,(unsigned int const *)arg2,(unsigned int const *)arg3);
13439
+ } catch (const native_exception &e) {
13440
+ e.regenerate();
13441
+ SWIG_fail;
13442
+ } catch (const std::exception& e) {
13443
+ SWIG_exception_fail(SWIG_RuntimeError, e.what());
13444
+ }
13445
+ }
13446
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 | 0 );
13447
+ return vresult;
13448
+ fail:
13449
+ return Qnil;
13450
+ }
13451
+
13452
+
13298
13453
  SWIGINTERN void
13299
13454
  free_Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg_(void *self) {
13300
13455
  Matrix< double,Array2D_Dense< double > > *arg1 = (Matrix< double,Array2D_Dense< double > > *)self;
@@ -13878,6 +14033,8 @@ _wrap_Matrix_FrozenComplexD___getitem__(int argc, VALUE *argv, VALUE self) {
13878
14033
  }
13879
14034
  temp3 = static_cast< unsigned int >(val3);
13880
14035
  arg3 = &temp3;
14036
+ raise_if_lt_zero_after_asval(*arg2);
14037
+ raise_if_lt_zero_after_asval(*arg3);
13881
14038
  {
13882
14039
  try {
13883
14040
  result = Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sc_MatViewBase_Sg____getitem__((Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewBase< > > const *)arg1,(unsigned int const &)*arg2,(unsigned int const &)*arg3);
@@ -14006,6 +14163,10 @@ _wrap_Matrix_FrozenComplexD_circular__SWIG_0(int argc, VALUE *argv, VALUE self)
14006
14163
  }
14007
14164
  temp5 = static_cast< unsigned int >(val5);
14008
14165
  arg5 = &temp5;
14166
+ raise_if_lt_zero_after_asval(*arg2);
14167
+ raise_if_lt_zero_after_asval(*arg3);
14168
+ raise_if_lt_zero_after_asval(*arg4);
14169
+ raise_if_lt_zero_after_asval(*arg5);
14009
14170
  {
14010
14171
  try {
14011
14172
  result = Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sc_MatViewBase_Sg__circular__SWIG_0((Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewBase< > > const *)arg1,(unsigned int const &)*arg2,(unsigned int const &)*arg3,(unsigned int const &)*arg4,(unsigned int const &)*arg5);
@@ -14059,6 +14220,8 @@ _wrap_Matrix_FrozenComplexD_circular__SWIG_1(int argc, VALUE *argv, VALUE self)
14059
14220
  }
14060
14221
  temp3 = static_cast< unsigned int >(val3);
14061
14222
  arg3 = &temp3;
14223
+ raise_if_lt_zero_after_asval(*arg2);
14224
+ raise_if_lt_zero_after_asval(*arg3);
14062
14225
  {
14063
14226
  try {
14064
14227
  result = Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sc_MatViewBase_Sg__circular__SWIG_1((Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewBase< > > const *)arg1,(unsigned int const &)*arg2,(unsigned int const &)*arg3);
@@ -16142,6 +16305,10 @@ _wrap_Matrix_FrozenComplexD_partial(int argc, VALUE *argv, VALUE self) {
16142
16305
  }
16143
16306
  temp5 = static_cast< unsigned int >(val5);
16144
16307
  arg5 = &temp5;
16308
+ raise_if_lt_zero_after_asval(*arg2);
16309
+ raise_if_lt_zero_after_asval(*arg3);
16310
+ raise_if_lt_zero_after_asval(*arg4);
16311
+ raise_if_lt_zero_after_asval(*arg5);
16145
16312
  {
16146
16313
  try {
16147
16314
  result = Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sc_MatViewBase_Sg__partial((Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewBase< > > const *)arg1,(unsigned int const &)*arg2,(unsigned int const &)*arg3,(unsigned int const &)*arg4,(unsigned int const &)*arg5);
@@ -16194,6 +16361,7 @@ _wrap_Matrix_FrozenComplexD_row_vector(int argc, VALUE *argv, VALUE self) {
16194
16361
  }
16195
16362
  temp2 = static_cast< unsigned int >(val2);
16196
16363
  arg2 = &temp2;
16364
+ raise_if_lt_zero_after_asval(*arg2);
16197
16365
  {
16198
16366
  try {
16199
16367
  result = Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sc_MatViewBase_Sg__row_vector((Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewBase< > > const *)arg1,(unsigned int const &)*arg2);
@@ -16246,6 +16414,7 @@ _wrap_Matrix_FrozenComplexD_column_vector(int argc, VALUE *argv, VALUE self) {
16246
16414
  }
16247
16415
  temp2 = static_cast< unsigned int >(val2);
16248
16416
  arg2 = &temp2;
16417
+ raise_if_lt_zero_after_asval(*arg2);
16249
16418
  {
16250
16419
  try {
16251
16420
  result = Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sc_MatViewBase_Sg__column_vector((Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewBase< > > const *)arg1,(unsigned int const &)*arg2);
@@ -16903,6 +17072,8 @@ _wrap_Matrix_FrozenComplexD_f___getitem__(int argc, VALUE *argv, VALUE self) {
16903
17072
  }
16904
17073
  temp3 = static_cast< unsigned int >(val3);
16905
17074
  arg3 = &temp3;
17075
+ raise_if_lt_zero_after_asval(*arg2);
17076
+ raise_if_lt_zero_after_asval(*arg3);
16906
17077
  {
16907
17078
  try {
16908
17079
  result = Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sc_MatView_f_Sg____getitem__((Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewFilter< MatrixViewBase< > > > const *)arg1,(unsigned int const &)*arg2,(unsigned int const &)*arg3);
@@ -17031,6 +17202,10 @@ _wrap_Matrix_FrozenComplexD_f_circular__SWIG_0(int argc, VALUE *argv, VALUE self
17031
17202
  }
17032
17203
  temp5 = static_cast< unsigned int >(val5);
17033
17204
  arg5 = &temp5;
17205
+ raise_if_lt_zero_after_asval(*arg2);
17206
+ raise_if_lt_zero_after_asval(*arg3);
17207
+ raise_if_lt_zero_after_asval(*arg4);
17208
+ raise_if_lt_zero_after_asval(*arg5);
17034
17209
  {
17035
17210
  try {
17036
17211
  result = Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sc_MatView_f_Sg__circular__SWIG_0((Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewFilter< MatrixViewBase< > > > const *)arg1,(unsigned int const &)*arg2,(unsigned int const &)*arg3,(unsigned int const &)*arg4,(unsigned int const &)*arg5);
@@ -17084,6 +17259,8 @@ _wrap_Matrix_FrozenComplexD_f_circular__SWIG_1(int argc, VALUE *argv, VALUE self
17084
17259
  }
17085
17260
  temp3 = static_cast< unsigned int >(val3);
17086
17261
  arg3 = &temp3;
17262
+ raise_if_lt_zero_after_asval(*arg2);
17263
+ raise_if_lt_zero_after_asval(*arg3);
17087
17264
  {
17088
17265
  try {
17089
17266
  result = Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sc_MatView_f_Sg__circular__SWIG_1((Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewFilter< MatrixViewBase< > > > const *)arg1,(unsigned int const &)*arg2,(unsigned int const &)*arg3);
@@ -19167,6 +19344,10 @@ _wrap_Matrix_FrozenComplexD_f_partial(int argc, VALUE *argv, VALUE self) {
19167
19344
  }
19168
19345
  temp5 = static_cast< unsigned int >(val5);
19169
19346
  arg5 = &temp5;
19347
+ raise_if_lt_zero_after_asval(*arg2);
19348
+ raise_if_lt_zero_after_asval(*arg3);
19349
+ raise_if_lt_zero_after_asval(*arg4);
19350
+ raise_if_lt_zero_after_asval(*arg5);
19170
19351
  {
19171
19352
  try {
19172
19353
  result = Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sc_MatView_f_Sg__partial((Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewFilter< MatrixViewBase< > > > const *)arg1,(unsigned int const &)*arg2,(unsigned int const &)*arg3,(unsigned int const &)*arg4,(unsigned int const &)*arg5);
@@ -19219,6 +19400,7 @@ _wrap_Matrix_FrozenComplexD_f_row_vector(int argc, VALUE *argv, VALUE self) {
19219
19400
  }
19220
19401
  temp2 = static_cast< unsigned int >(val2);
19221
19402
  arg2 = &temp2;
19403
+ raise_if_lt_zero_after_asval(*arg2);
19222
19404
  {
19223
19405
  try {
19224
19406
  result = Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sc_MatView_f_Sg__row_vector((Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewFilter< MatrixViewBase< > > > const *)arg1,(unsigned int const &)*arg2);
@@ -19271,6 +19453,7 @@ _wrap_Matrix_FrozenComplexD_f_column_vector(int argc, VALUE *argv, VALUE self) {
19271
19453
  }
19272
19454
  temp2 = static_cast< unsigned int >(val2);
19273
19455
  arg2 = &temp2;
19456
+ raise_if_lt_zero_after_asval(*arg2);
19274
19457
  {
19275
19458
  try {
19276
19459
  result = Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sc_MatView_f_Sg__column_vector((Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewFilter< MatrixViewBase< > > > const *)arg1,(unsigned int const &)*arg2);
@@ -19360,130 +19543,6 @@ free_Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_doubl
19360
19543
  */
19361
19544
  static swig_class SwigClassMatrixComplexD;
19362
19545
 
19363
- /*
19364
- Document-method: GPS_PVT::SylphideMath::MatrixComplexD.swap_rows
19365
-
19366
- call-seq:
19367
- swap_rows(unsigned int const & row1, unsigned int const & row2) -> MatrixComplexD
19368
-
19369
- An instance method.
19370
-
19371
- */
19372
- SWIGINTERN VALUE
19373
- _wrap_MatrixComplexD_swap_rowsN___(int argc, VALUE *argv, VALUE self) {
19374
- Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *arg1 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *) 0 ;
19375
- unsigned int *arg2 = 0 ;
19376
- unsigned int *arg3 = 0 ;
19377
- void *argp1 = 0 ;
19378
- int res1 = 0 ;
19379
- unsigned int temp2 ;
19380
- unsigned int val2 ;
19381
- int ecode2 = 0 ;
19382
- unsigned int temp3 ;
19383
- unsigned int val3 ;
19384
- int ecode3 = 0 ;
19385
- Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *result = 0 ;
19386
- VALUE vresult = Qnil;
19387
-
19388
- if ((argc < 2) || (argc > 2)) {
19389
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
19390
- }
19391
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0 | 0 );
19392
- if (!SWIG_IsOK(res1)) {
19393
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *","swapRows", 1, self ));
19394
- }
19395
- arg1 = reinterpret_cast< Matrix< Complex< double >,Array2D_Dense< Complex< double > > > * >(argp1);
19396
- ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
19397
- if (!SWIG_IsOK(ecode2)) {
19398
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","swapRows", 2, argv[0] ));
19399
- }
19400
- temp2 = static_cast< unsigned int >(val2);
19401
- arg2 = &temp2;
19402
- ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
19403
- if (!SWIG_IsOK(ecode3)) {
19404
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","swapRows", 3, argv[1] ));
19405
- }
19406
- temp3 = static_cast< unsigned int >(val3);
19407
- arg3 = &temp3;
19408
- {
19409
- try {
19410
- result = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *) &(arg1)->swapRows((unsigned int const &)*arg2,(unsigned int const &)*arg3);
19411
- } catch (const native_exception &e) {
19412
- e.regenerate();
19413
- SWIG_fail;
19414
- } catch (const std::exception& e) {
19415
- SWIG_exception_fail(SWIG_RuntimeError, e.what());
19416
- }
19417
- }
19418
- vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0 | 0 );
19419
- return vresult;
19420
- fail:
19421
- return Qnil;
19422
- }
19423
-
19424
-
19425
- /*
19426
- Document-method: GPS_PVT::SylphideMath::MatrixComplexD.swap_columns
19427
-
19428
- call-seq:
19429
- swap_columns(unsigned int const & column1, unsigned int const & column2) -> MatrixComplexD
19430
-
19431
- An instance method.
19432
-
19433
- */
19434
- SWIGINTERN VALUE
19435
- _wrap_MatrixComplexD_swap_columnsN___(int argc, VALUE *argv, VALUE self) {
19436
- Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *arg1 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *) 0 ;
19437
- unsigned int *arg2 = 0 ;
19438
- unsigned int *arg3 = 0 ;
19439
- void *argp1 = 0 ;
19440
- int res1 = 0 ;
19441
- unsigned int temp2 ;
19442
- unsigned int val2 ;
19443
- int ecode2 = 0 ;
19444
- unsigned int temp3 ;
19445
- unsigned int val3 ;
19446
- int ecode3 = 0 ;
19447
- Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *result = 0 ;
19448
- VALUE vresult = Qnil;
19449
-
19450
- if ((argc < 2) || (argc > 2)) {
19451
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
19452
- }
19453
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0 | 0 );
19454
- if (!SWIG_IsOK(res1)) {
19455
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *","swapColumns", 1, self ));
19456
- }
19457
- arg1 = reinterpret_cast< Matrix< Complex< double >,Array2D_Dense< Complex< double > > > * >(argp1);
19458
- ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
19459
- if (!SWIG_IsOK(ecode2)) {
19460
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","swapColumns", 2, argv[0] ));
19461
- }
19462
- temp2 = static_cast< unsigned int >(val2);
19463
- arg2 = &temp2;
19464
- ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
19465
- if (!SWIG_IsOK(ecode3)) {
19466
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","swapColumns", 3, argv[1] ));
19467
- }
19468
- temp3 = static_cast< unsigned int >(val3);
19469
- arg3 = &temp3;
19470
- {
19471
- try {
19472
- result = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *) &(arg1)->swapColumns((unsigned int const &)*arg2,(unsigned int const &)*arg3);
19473
- } catch (const native_exception &e) {
19474
- e.regenerate();
19475
- SWIG_fail;
19476
- } catch (const std::exception& e) {
19477
- SWIG_exception_fail(SWIG_RuntimeError, e.what());
19478
- }
19479
- }
19480
- vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0 | 0 );
19481
- return vresult;
19482
- fail:
19483
- return Qnil;
19484
- }
19485
-
19486
-
19487
19546
  /*
19488
19547
  Document-method: GPS_PVT::SylphideMath::MatrixComplexD.new
19489
19548
 
@@ -19527,6 +19586,8 @@ _wrap_new_MatrixComplexD__SWIG_0(int argc, VALUE *argv, VALUE self) {
19527
19586
  {
19528
19587
  arg3 = &argv[2];
19529
19588
  }
19589
+ raise_if_lt_zero_after_asval(*arg1);
19590
+ raise_if_lt_zero_after_asval(*arg2);
19530
19591
  {
19531
19592
  try {
19532
19593
  result = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *)new_Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg___SWIG_0((unsigned int const &)*arg1,(unsigned int const &)*arg2,(void const *)arg3);
@@ -19571,6 +19632,8 @@ _wrap_new_MatrixComplexD__SWIG_1(int argc, VALUE *argv, VALUE self) {
19571
19632
  }
19572
19633
  temp2 = static_cast< unsigned int >(val2);
19573
19634
  arg2 = &temp2;
19635
+ raise_if_lt_zero_after_asval(*arg1);
19636
+ raise_if_lt_zero_after_asval(*arg2);
19574
19637
  {
19575
19638
  try {
19576
19639
  result = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *)new_Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg___SWIG_0((unsigned int const &)*arg1,(unsigned int const &)*arg2);
@@ -19623,6 +19686,8 @@ _wrap_new_MatrixComplexD__SWIG_2(int argc, VALUE *argv, VALUE self) {
19623
19686
  SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Complex< double > const *","Matrix<(Complex<(double)>,Array2D_Dense<(Complex<(double)>)>)>", 3, argv[2] ));
19624
19687
  }
19625
19688
  arg3 = reinterpret_cast< Complex< double > * >(argp3);
19689
+ raise_if_lt_zero_after_asval(*arg1);
19690
+ raise_if_lt_zero_after_asval(*arg2);
19626
19691
  {
19627
19692
  try {
19628
19693
  result = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *)new_Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg___SWIG_2((unsigned int const &)*arg1,(unsigned int const &)*arg2,(Complex< double > const *)arg3);
@@ -19830,6 +19895,8 @@ _wrap_MatrixComplexD___setitem__(int argc, VALUE *argv, VALUE self) {
19830
19895
  SWIG_exception(SWIG_TypeError, "in method '__setitem__', expecting type Complex< double >");
19831
19896
  }
19832
19897
  }
19898
+ raise_if_lt_zero_after_asval(*arg2);
19899
+ raise_if_lt_zero_after_asval(*arg3);
19833
19900
  {
19834
19901
  try {
19835
19902
  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);
@@ -19882,6 +19949,7 @@ _wrap_MatrixComplexD_scalar(int argc, VALUE *argv, VALUE self) {
19882
19949
  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 >");
19883
19950
  }
19884
19951
  }
19952
+ raise_if_lt_zero_after_asval(*arg1);
19885
19953
  {
19886
19954
  try {
19887
19955
  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);
@@ -19926,6 +19994,7 @@ _wrap_MatrixComplexD_I(int argc, VALUE *argv, VALUE self) {
19926
19994
  }
19927
19995
  temp1 = static_cast< unsigned int >(val1);
19928
19996
  arg1 = &temp1;
19997
+ raise_if_lt_zero_after_asval(*arg1);
19929
19998
  {
19930
19999
  try {
19931
20000
  result = Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__getI((unsigned int const &)*arg1);
@@ -19943,29 +20012,160 @@ fail:
19943
20012
  }
19944
20013
 
19945
20014
 
20015
+ /*
20016
+ Document-method: GPS_PVT::SylphideMath::MatrixComplexD.swap_rows
20017
+
20018
+ call-seq:
20019
+ swap_rows(unsigned int const & r1, unsigned int const & r2)
20020
+
20021
+ An instance method.
20022
+
20023
+ */
20024
+ SWIGINTERN VALUE
20025
+ _wrap_MatrixComplexD_swap_rowsN___(int argc, VALUE *argv, VALUE self) {
20026
+ Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *arg1 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *) 0 ;
20027
+ Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *arg2 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *) 0 ;
20028
+ unsigned int *arg3 = 0 ;
20029
+ unsigned int *arg4 = 0 ;
20030
+ void *argp1 = 0 ;
20031
+ int res1 = 0 ;
20032
+ unsigned int temp3 ;
20033
+ unsigned int val3 ;
20034
+ int ecode3 = 0 ;
20035
+ unsigned int temp4 ;
20036
+ unsigned int val4 ;
20037
+ int ecode4 = 0 ;
20038
+ VALUE vresult = Qnil;
20039
+
20040
+
20041
+ if ((argc < 2) || (argc > 2)) {
20042
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
20043
+ }
20044
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0 | 0 );
20045
+ if (!SWIG_IsOK(res1)) {
20046
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *","swap_rows", 1, self ));
20047
+ }
20048
+ arg1 = reinterpret_cast< Matrix< Complex< double >,Array2D_Dense< Complex< double > > > * >(argp1);
20049
+ ecode3 = SWIG_AsVal_unsigned_SS_int(argv[0], &val3);
20050
+ if (!SWIG_IsOK(ecode3)) {
20051
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","swap_rows", 3, argv[0] ));
20052
+ }
20053
+ temp3 = static_cast< unsigned int >(val3);
20054
+ arg3 = &temp3;
20055
+ ecode4 = SWIG_AsVal_unsigned_SS_int(argv[1], &val4);
20056
+ if (!SWIG_IsOK(ecode4)) {
20057
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","swap_rows", 4, argv[1] ));
20058
+ }
20059
+ temp4 = static_cast< unsigned int >(val4);
20060
+ arg4 = &temp4;
20061
+ raise_if_lt_zero_after_asval(*arg3);
20062
+ raise_if_lt_zero_after_asval(*arg4);
20063
+ {
20064
+ try {
20065
+ 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);
20066
+ } catch (const native_exception &e) {
20067
+ e.regenerate();
20068
+ SWIG_fail;
20069
+ } catch (const std::exception& e) {
20070
+ SWIG_exception_fail(SWIG_RuntimeError, e.what());
20071
+ }
20072
+ }
20073
+ vresult = self;
20074
+ return vresult;
20075
+ fail:
20076
+ return Qnil;
20077
+ }
20078
+
20079
+
20080
+ /*
20081
+ Document-method: GPS_PVT::SylphideMath::MatrixComplexD.swap_columns
20082
+
20083
+ call-seq:
20084
+ swap_columns(unsigned int const & c1, unsigned int const & c2)
20085
+
20086
+ An instance method.
20087
+
20088
+ */
20089
+ SWIGINTERN VALUE
20090
+ _wrap_MatrixComplexD_swap_columnsN___(int argc, VALUE *argv, VALUE self) {
20091
+ Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *arg1 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *) 0 ;
20092
+ Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *arg2 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *) 0 ;
20093
+ unsigned int *arg3 = 0 ;
20094
+ unsigned int *arg4 = 0 ;
20095
+ void *argp1 = 0 ;
20096
+ int res1 = 0 ;
20097
+ unsigned int temp3 ;
20098
+ unsigned int val3 ;
20099
+ int ecode3 = 0 ;
20100
+ unsigned int temp4 ;
20101
+ unsigned int val4 ;
20102
+ int ecode4 = 0 ;
20103
+ VALUE vresult = Qnil;
20104
+
20105
+
20106
+ if ((argc < 2) || (argc > 2)) {
20107
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
20108
+ }
20109
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0 | 0 );
20110
+ if (!SWIG_IsOK(res1)) {
20111
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *","swap_columns", 1, self ));
20112
+ }
20113
+ arg1 = reinterpret_cast< Matrix< Complex< double >,Array2D_Dense< Complex< double > > > * >(argp1);
20114
+ ecode3 = SWIG_AsVal_unsigned_SS_int(argv[0], &val3);
20115
+ if (!SWIG_IsOK(ecode3)) {
20116
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","swap_columns", 3, argv[0] ));
20117
+ }
20118
+ temp3 = static_cast< unsigned int >(val3);
20119
+ arg3 = &temp3;
20120
+ ecode4 = SWIG_AsVal_unsigned_SS_int(argv[1], &val4);
20121
+ if (!SWIG_IsOK(ecode4)) {
20122
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","swap_columns", 4, argv[1] ));
20123
+ }
20124
+ temp4 = static_cast< unsigned int >(val4);
20125
+ arg4 = &temp4;
20126
+ raise_if_lt_zero_after_asval(*arg3);
20127
+ raise_if_lt_zero_after_asval(*arg4);
20128
+ {
20129
+ try {
20130
+ 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);
20131
+ } catch (const native_exception &e) {
20132
+ e.regenerate();
20133
+ SWIG_fail;
20134
+ } catch (const std::exception& e) {
20135
+ SWIG_exception_fail(SWIG_RuntimeError, e.what());
20136
+ }
20137
+ }
20138
+ vresult = self;
20139
+ return vresult;
20140
+ fail:
20141
+ return Qnil;
20142
+ }
20143
+
20144
+
19946
20145
  /*
19947
20146
  Document-method: GPS_PVT::SylphideMath::MatrixComplexD.replace!
19948
20147
 
19949
20148
  call-seq:
19950
- replace!(matrix) -> MatrixComplexD
19951
- replace!(matrix) -> MatrixComplexD
19952
- replace!(replacer=nil) -> MatrixComplexD
19953
- replace! -> MatrixComplexD
19954
- replace!(serialized) -> MatrixComplexD
20149
+ replace!(matrix)
20150
+ replace!(matrix)
20151
+ replace!(replacer=nil)
20152
+ replace!
20153
+ replace!(serialized)
19955
20154
 
19956
20155
  Replace all or a portion of the MatrixComplexD.
19957
20156
  */
19958
20157
  SWIGINTERN VALUE
19959
20158
  _wrap_MatrixComplexD_replaceN_____SWIG_1(int argc, VALUE *argv, VALUE self) {
19960
20159
  Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *arg1 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *) 0 ;
19961
- Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewBase< > > *arg2 = 0 ;
20160
+ Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *arg2 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *) 0 ;
20161
+ Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewBase< > > *arg3 = 0 ;
19962
20162
  void *argp1 = 0 ;
19963
20163
  int res1 = 0 ;
19964
- void *argp2 ;
19965
- int res2 = 0 ;
19966
- Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *result = 0 ;
20164
+ void *argp3 ;
20165
+ int res3 = 0 ;
19967
20166
  VALUE vresult = Qnil;
19968
20167
 
20168
+
19969
20169
  if ((argc < 1) || (argc > 1)) {
19970
20170
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
19971
20171
  }
@@ -19974,17 +20174,17 @@ _wrap_MatrixComplexD_replaceN_____SWIG_1(int argc, VALUE *argv, VALUE self) {
19974
20174
  SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *","replace<(T,Array2D_Dense<(T)>,MatViewBase)>", 1, self ));
19975
20175
  }
19976
20176
  arg1 = reinterpret_cast< Matrix< Complex< double >,Array2D_Dense< Complex< double > > > * >(argp1);
19977
- res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Matrix_FrozenT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0 );
19978
- if (!SWIG_IsOK(res2)) {
19979
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewBase< > > const &","replace<(T,Array2D_Dense<(T)>,MatViewBase)>", 2, argv[0] ));
20177
+ res3 = SWIG_ConvertPtr(argv[0], &argp3, SWIGTYPE_p_Matrix_FrozenT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0 );
20178
+ if (!SWIG_IsOK(res3)) {
20179
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewBase< > > const &","replace<(T,Array2D_Dense<(T)>,MatViewBase)>", 3, argv[0] ));
19980
20180
  }
19981
- if (!argp2) {
19982
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewBase< > > const &","replace<(T,Array2D_Dense<(T)>,MatViewBase)>", 2, argv[0]));
20181
+ if (!argp3) {
20182
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewBase< > > const &","replace<(T,Array2D_Dense<(T)>,MatViewBase)>", 3, argv[0]));
19983
20183
  }
19984
- arg2 = reinterpret_cast< Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewBase< > > * >(argp2);
20184
+ arg3 = reinterpret_cast< Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewBase< > > * >(argp3);
19985
20185
  {
19986
20186
  try {
19987
- result = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *) &Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__replace_Sl_T_Sc_Array2D_Dense_Sl_T_Sg__Sc_MatViewBase_Sg___SWIG_1(arg1,(Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewBase< > > const &)*arg2);
20187
+ Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__replace_Sl_T_Sc_Array2D_Dense_Sl_T_Sg__Sc_MatViewBase_Sg___SWIG_1(arg1,arg2,(Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewBase< > > const &)*arg3);
19988
20188
  } catch (const native_exception &e) {
19989
20189
  e.regenerate();
19990
20190
  SWIG_fail;
@@ -20002,14 +20202,15 @@ fail:
20002
20202
  SWIGINTERN VALUE
20003
20203
  _wrap_MatrixComplexD_replaceN_____SWIG_2(int argc, VALUE *argv, VALUE self) {
20004
20204
  Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *arg1 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *) 0 ;
20005
- Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewFilter< MatrixViewBase< > > > *arg2 = 0 ;
20205
+ Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *arg2 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *) 0 ;
20206
+ Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewFilter< MatrixViewBase< > > > *arg3 = 0 ;
20006
20207
  void *argp1 = 0 ;
20007
20208
  int res1 = 0 ;
20008
- void *argp2 ;
20009
- int res2 = 0 ;
20010
- Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *result = 0 ;
20209
+ void *argp3 ;
20210
+ int res3 = 0 ;
20011
20211
  VALUE vresult = Qnil;
20012
20212
 
20213
+
20013
20214
  if ((argc < 1) || (argc > 1)) {
20014
20215
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
20015
20216
  }
@@ -20018,17 +20219,17 @@ _wrap_MatrixComplexD_replaceN_____SWIG_2(int argc, VALUE *argv, VALUE self) {
20018
20219
  SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *","replace<(T,Array2D_Dense<(T)>,MatView_f)>", 1, self ));
20019
20220
  }
20020
20221
  arg1 = reinterpret_cast< Matrix< Complex< double >,Array2D_Dense< Complex< double > > > * >(argp1);
20021
- res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Matrix_FrozenT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewFilterT_MatrixViewBaseT_t_t_t, 0 );
20022
- if (!SWIG_IsOK(res2)) {
20023
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewFilter< MatrixViewBase< > > > const &","replace<(T,Array2D_Dense<(T)>,MatView_f)>", 2, argv[0] ));
20222
+ res3 = SWIG_ConvertPtr(argv[0], &argp3, SWIGTYPE_p_Matrix_FrozenT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewFilterT_MatrixViewBaseT_t_t_t, 0 );
20223
+ if (!SWIG_IsOK(res3)) {
20224
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewFilter< MatrixViewBase< > > > const &","replace<(T,Array2D_Dense<(T)>,MatView_f)>", 3, argv[0] ));
20024
20225
  }
20025
- if (!argp2) {
20026
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewFilter< MatrixViewBase< > > > const &","replace<(T,Array2D_Dense<(T)>,MatView_f)>", 2, argv[0]));
20226
+ if (!argp3) {
20227
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewFilter< MatrixViewBase< > > > const &","replace<(T,Array2D_Dense<(T)>,MatView_f)>", 3, argv[0]));
20027
20228
  }
20028
- arg2 = reinterpret_cast< Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewFilter< MatrixViewBase< > > > * >(argp2);
20229
+ arg3 = reinterpret_cast< Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewFilter< MatrixViewBase< > > > * >(argp3);
20029
20230
  {
20030
20231
  try {
20031
- result = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *) &Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__replace_Sl_T_Sc_Array2D_Dense_Sl_T_Sg__Sc_MatView_f_Sg___SWIG_2(arg1,(Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewFilter< MatrixViewBase< > > > const &)*arg2);
20232
+ Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__replace_Sl_T_Sc_Array2D_Dense_Sl_T_Sg__Sc_MatView_f_Sg___SWIG_2(arg1,arg2,(Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewFilter< MatrixViewBase< > > > const &)*arg3);
20032
20233
  } catch (const native_exception &e) {
20033
20234
  e.regenerate();
20034
20235
  SWIG_fail;
@@ -20046,12 +20247,13 @@ fail:
20046
20247
  SWIGINTERN VALUE
20047
20248
  _wrap_MatrixComplexD_replaceN_____SWIG_3(int argc, VALUE *argv, VALUE self) {
20048
20249
  Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *arg1 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *) 0 ;
20049
- void *arg2 = (void *) 0 ;
20250
+ Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *arg2 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *) 0 ;
20251
+ void *arg3 = (void *) 0 ;
20050
20252
  void *argp1 = 0 ;
20051
20253
  int res1 = 0 ;
20052
- Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *result = 0 ;
20053
20254
  VALUE vresult = Qnil;
20054
20255
 
20256
+
20055
20257
  if ((argc < 1) || (argc > 1)) {
20056
20258
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
20057
20259
  }
@@ -20061,11 +20263,11 @@ _wrap_MatrixComplexD_replaceN_____SWIG_3(int argc, VALUE *argv, VALUE self) {
20061
20263
  }
20062
20264
  arg1 = reinterpret_cast< Matrix< Complex< double >,Array2D_Dense< Complex< double > > > * >(argp1);
20063
20265
  {
20064
- arg2 = &argv[0];
20266
+ arg3 = &argv[0];
20065
20267
  }
20066
20268
  {
20067
20269
  try {
20068
- result = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *) &Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__replace__SWIG_3(arg1,(void const *)arg2);
20270
+ Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__replace__SWIG_3(arg1,arg2,(void const *)arg3);
20069
20271
  } catch (const native_exception &e) {
20070
20272
  e.regenerate();
20071
20273
  SWIG_fail;
@@ -20083,11 +20285,12 @@ fail:
20083
20285
  SWIGINTERN VALUE
20084
20286
  _wrap_MatrixComplexD_replaceN_____SWIG_4(int argc, VALUE *argv, VALUE self) {
20085
20287
  Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *arg1 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *) 0 ;
20288
+ Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *arg2 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *) 0 ;
20086
20289
  void *argp1 = 0 ;
20087
20290
  int res1 = 0 ;
20088
- Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *result = 0 ;
20089
20291
  VALUE vresult = Qnil;
20090
20292
 
20293
+
20091
20294
  if ((argc < 0) || (argc > 0)) {
20092
20295
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
20093
20296
  }
@@ -20098,7 +20301,7 @@ _wrap_MatrixComplexD_replaceN_____SWIG_4(int argc, VALUE *argv, VALUE self) {
20098
20301
  arg1 = reinterpret_cast< Matrix< Complex< double >,Array2D_Dense< Complex< double > > > * >(argp1);
20099
20302
  {
20100
20303
  try {
20101
- result = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *) &Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__replace__SWIG_3(arg1);
20304
+ Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__replace__SWIG_3(arg1,arg2);
20102
20305
  } catch (const native_exception &e) {
20103
20306
  e.regenerate();
20104
20307
  SWIG_fail;
@@ -20116,14 +20319,15 @@ fail:
20116
20319
  SWIGINTERN VALUE
20117
20320
  _wrap_MatrixComplexD_replaceN_____SWIG_5(int argc, VALUE *argv, VALUE self) {
20118
20321
  Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *arg1 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *) 0 ;
20119
- Complex< double > *arg2 = (Complex< double > *) 0 ;
20322
+ Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *arg2 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *) 0 ;
20323
+ Complex< double > *arg3 = (Complex< double > *) 0 ;
20120
20324
  void *argp1 = 0 ;
20121
20325
  int res1 = 0 ;
20122
- void *argp2 = 0 ;
20123
- int res2 = 0 ;
20124
- Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *result = 0 ;
20326
+ void *argp3 = 0 ;
20327
+ int res3 = 0 ;
20125
20328
  VALUE vresult = Qnil;
20126
20329
 
20330
+
20127
20331
  if ((argc < 1) || (argc > 1)) {
20128
20332
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
20129
20333
  }
@@ -20132,14 +20336,14 @@ _wrap_MatrixComplexD_replaceN_____SWIG_5(int argc, VALUE *argv, VALUE self) {
20132
20336
  SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *","replace", 1, self ));
20133
20337
  }
20134
20338
  arg1 = reinterpret_cast< Matrix< Complex< double >,Array2D_Dense< Complex< double > > > * >(argp1);
20135
- res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_ComplexT_double_t, 0 | 0 );
20136
- if (!SWIG_IsOK(res2)) {
20137
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Complex< double > const *","replace", 2, argv[0] ));
20339
+ res3 = SWIG_ConvertPtr(argv[0], &argp3,SWIGTYPE_p_ComplexT_double_t, 0 | 0 );
20340
+ if (!SWIG_IsOK(res3)) {
20341
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Complex< double > const *","replace", 3, argv[0] ));
20138
20342
  }
20139
- arg2 = reinterpret_cast< Complex< double > * >(argp2);
20343
+ arg3 = reinterpret_cast< Complex< double > * >(argp3);
20140
20344
  {
20141
20345
  try {
20142
- result = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *) &Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__replace__SWIG_5(arg1,(Complex< double > const *)arg2);
20346
+ Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__replace__SWIG_5(arg1,arg2,(Complex< double > const *)arg3);
20143
20347
  } catch (const native_exception &e) {
20144
20348
  e.regenerate();
20145
20349
  SWIG_fail;
@@ -20236,11 +20440,11 @@ SWIGINTERN VALUE _wrap_MatrixComplexD_replaceN___(int nargs, VALUE *args, VALUE
20236
20440
 
20237
20441
  fail:
20238
20442
  Ruby_Format_OverloadedError( argc, 3, "replace!",
20239
- " Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t replace!(Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewBase< > > const &matrix)\n"
20240
- " Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t replace!(Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewFilter< MatrixViewBase< > > > const &matrix)\n"
20241
- " Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t replace!(void const *replacer)\n"
20242
- " Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t replace!()\n"
20243
- " Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t & replace!(Complex< double > const *serialized)\n");
20443
+ " 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"
20444
+ " 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"
20445
+ " void replace!(Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *self_p, void const *replacer)\n"
20446
+ " void replace!(Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *self_p)\n"
20447
+ " void replace!(Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *self_p, Complex< double > const *serialized)\n");
20244
20448
 
20245
20449
  return Qnil;
20246
20450
  }
@@ -20250,8 +20454,8 @@ fail:
20250
20454
  Document-method: GPS_PVT::SylphideMath::MatrixComplexD.map!
20251
20455
 
20252
20456
  call-seq:
20253
- map!(MatrixUtil::each_which_t const & each_which=MatrixUtil::EACH_ALL) -> MatrixComplexD
20254
- map! -> MatrixComplexD
20457
+ map!(MatrixUtil::each_which_t const & each_which=MatrixUtil::EACH_ALL)
20458
+ map!
20255
20459
 
20256
20460
  An instance method.
20257
20461
 
@@ -20259,18 +20463,19 @@ An instance method.
20259
20463
  SWIGINTERN VALUE
20260
20464
  _wrap_MatrixComplexD_mapN_____SWIG_0(int argc, VALUE *argv, VALUE self) {
20261
20465
  Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *arg1 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *) 0 ;
20262
- void (*arg2)(Complex< double > const &,Complex< double > *,unsigned int const &,unsigned int const &) = (void (*)(Complex< double > const &,Complex< double > *,unsigned int const &,unsigned int const &)) 0 ;
20263
- MatrixUtil::each_which_t *arg3 = 0 ;
20466
+ Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *arg2 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *) 0 ;
20467
+ void (*arg3)(Complex< double > const &,Complex< double > *,unsigned int const &,unsigned int const &) = (void (*)(Complex< double > const &,Complex< double > *,unsigned int const &,unsigned int const &)) 0 ;
20468
+ MatrixUtil::each_which_t *arg4 = 0 ;
20264
20469
  void *argp1 = 0 ;
20265
20470
  int res1 = 0 ;
20266
- Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *result = 0 ;
20267
20471
  VALUE vresult = Qnil;
20268
20472
 
20473
+
20269
20474
  {
20270
20475
  if(!rb_block_given_p()){
20271
20476
  return rb_enumeratorize(self, ID2SYM(rb_frame_callee()), argc, argv);
20272
20477
  }
20273
- arg2 = matrix_each((const Complex< double > *)0);
20478
+ arg3 = matrix_each((const Complex< double > *)0);
20274
20479
  }
20275
20480
  if ((argc < 1) || (argc > 1)) {
20276
20481
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
@@ -20282,14 +20487,14 @@ _wrap_MatrixComplexD_mapN_____SWIG_0(int argc, VALUE *argv, VALUE self) {
20282
20487
  arg1 = reinterpret_cast< Matrix< Complex< double >,Array2D_Dense< Complex< double > > > * >(argp1);
20283
20488
  {
20284
20489
  try{
20285
- arg3 = &const_cast<typename MatrixUtil::each_which_t &>(MatrixUtil::sym2each_which(argv[0]));
20490
+ arg4 = &const_cast<typename MatrixUtil::each_which_t &>(MatrixUtil::sym2each_which(argv[0]));
20286
20491
  }catch(std::runtime_error &e){
20287
20492
  SWIG_exception(SWIG_TypeError, e.what());
20288
20493
  }
20289
20494
  }
20290
20495
  {
20291
20496
  try {
20292
- result = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *) &Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__map_bang__SWIG_0(arg1,arg2,(MatrixUtil::each_which_t const &)*arg3);
20497
+ Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__map_bang__SWIG_0(arg1,arg2,arg3,(MatrixUtil::each_which_t const &)*arg4);
20293
20498
  } catch (const native_exception &e) {
20294
20499
  e.regenerate();
20295
20500
  SWIG_fail;
@@ -20307,17 +20512,18 @@ fail:
20307
20512
  SWIGINTERN VALUE
20308
20513
  _wrap_MatrixComplexD_mapN_____SWIG_1(int argc, VALUE *argv, VALUE self) {
20309
20514
  Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *arg1 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *) 0 ;
20310
- void (*arg2)(Complex< double > const &,Complex< double > *,unsigned int const &,unsigned int const &) = (void (*)(Complex< double > const &,Complex< double > *,unsigned int const &,unsigned int const &)) 0 ;
20515
+ Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *arg2 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *) 0 ;
20516
+ void (*arg3)(Complex< double > const &,Complex< double > *,unsigned int const &,unsigned int const &) = (void (*)(Complex< double > const &,Complex< double > *,unsigned int const &,unsigned int const &)) 0 ;
20311
20517
  void *argp1 = 0 ;
20312
20518
  int res1 = 0 ;
20313
- Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *result = 0 ;
20314
20519
  VALUE vresult = Qnil;
20315
20520
 
20521
+
20316
20522
  {
20317
20523
  if(!rb_block_given_p()){
20318
20524
  return rb_enumeratorize(self, ID2SYM(rb_frame_callee()), argc, argv);
20319
20525
  }
20320
- arg2 = matrix_each((const Complex< double > *)0);
20526
+ arg3 = matrix_each((const Complex< double > *)0);
20321
20527
  }
20322
20528
  if ((argc < 0) || (argc > 0)) {
20323
20529
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
@@ -20329,7 +20535,7 @@ _wrap_MatrixComplexD_mapN_____SWIG_1(int argc, VALUE *argv, VALUE self) {
20329
20535
  arg1 = reinterpret_cast< Matrix< Complex< double >,Array2D_Dense< Complex< double > > > * >(argp1);
20330
20536
  {
20331
20537
  try {
20332
- result = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t *) &Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__map_bang__SWIG_0(arg1,arg2);
20538
+ Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg__map_bang__SWIG_0(arg1,arg2,arg3);
20333
20539
  } catch (const native_exception &e) {
20334
20540
  e.regenerate();
20335
20541
  SWIG_fail;
@@ -20381,13 +20587,88 @@ SWIGINTERN VALUE _wrap_MatrixComplexD_mapN___(int nargs, VALUE *args, VALUE self
20381
20587
 
20382
20588
  fail:
20383
20589
  Ruby_Format_OverloadedError( argc, 3, "map!",
20384
- " Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t map!(void (*each_func)(Complex< double > const &,Complex< double > *,unsigned int const &,unsigned int const &), MatrixUtil::each_which_t const &each_which)\n"
20385
- " Matrix< Complex< double >,Array2D_Dense< Complex< double > > >::self_t & map!(void (*each_func)(Complex< double > const &,Complex< double > *,unsigned int const &,unsigned int const &))\n");
20590
+ " 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"
20591
+ " 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");
20386
20592
 
20387
20593
  return Qnil;
20388
20594
  }
20389
20595
 
20390
20596
 
20597
+ /*
20598
+ Document-method: GPS_PVT::SylphideMath::MatrixComplexD.resize
20599
+
20600
+ call-seq:
20601
+ resize(r_p, c_p) -> MatrixComplexD
20602
+
20603
+ Resize the size of the MatrixComplexD.
20604
+ */
20605
+ SWIGINTERN VALUE
20606
+ _wrap_MatrixComplexD_resizeN___(int argc, VALUE *argv, VALUE self) {
20607
+ Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *arg1 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *) 0 ;
20608
+ unsigned int *arg2 = (unsigned int *) 0 ;
20609
+ unsigned int *arg3 = (unsigned int *) 0 ;
20610
+ void *argp1 = 0 ;
20611
+ int res1 = 0 ;
20612
+ unsigned int temp2 ;
20613
+ unsigned int temp3 ;
20614
+ Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *result = 0 ;
20615
+ VALUE vresult = Qnil;
20616
+
20617
+ if ((argc < 2) || (argc > 2)) {
20618
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
20619
+ }
20620
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0 | 0 );
20621
+ if (!SWIG_IsOK(res1)) {
20622
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *","resize", 1, self ));
20623
+ }
20624
+ arg1 = reinterpret_cast< Matrix< Complex< double >,Array2D_Dense< Complex< double > > > * >(argp1);
20625
+ {
20626
+ if(SWIG_IsOK(SWIG_AsVal_unsigned_SS_int (argv[0], &temp2))){
20627
+ raise_if_lt_zero_after_asval(temp2);
20628
+
20629
+ arg2 = &temp2;
20630
+ }
20631
+
20632
+ else if(NIL_P(argv[0])){
20633
+ arg2 = NULL;
20634
+ }
20635
+
20636
+ else{
20637
+ SWIG_exception(SWIG_TypeError, "unsigned int is expected");
20638
+ }
20639
+ }
20640
+ {
20641
+ if(SWIG_IsOK(SWIG_AsVal_unsigned_SS_int (argv[1], &temp3))){
20642
+ raise_if_lt_zero_after_asval(temp3);
20643
+
20644
+ arg3 = &temp3;
20645
+ }
20646
+
20647
+ else if(NIL_P(argv[1])){
20648
+ arg3 = NULL;
20649
+ }
20650
+
20651
+ else{
20652
+ SWIG_exception(SWIG_TypeError, "unsigned int is expected");
20653
+ }
20654
+ }
20655
+ {
20656
+ try {
20657
+ 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);
20658
+ } catch (const native_exception &e) {
20659
+ e.regenerate();
20660
+ SWIG_fail;
20661
+ } catch (const std::exception& e) {
20662
+ SWIG_exception_fail(SWIG_RuntimeError, e.what());
20663
+ }
20664
+ }
20665
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0 | 0 );
20666
+ return vresult;
20667
+ fail:
20668
+ return Qnil;
20669
+ }
20670
+
20671
+
20391
20672
  SWIGINTERN void
20392
20673
  free_Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg_(void *self) {
20393
20674
  Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *arg1 = (Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *)self;
@@ -20418,6 +20699,7 @@ static swig_type_info _swigt__p_f_r_q_const__Complex__double___p_Complex__double
20418
20699
  static swig_type_info _swigt__p_f_r_q_const__double_p_double_r_q_const__unsigned_int_r_q_const__unsigned_int__void = {"_p_f_r_q_const__double_p_double_r_q_const__unsigned_int_r_q_const__unsigned_int__void", "void (*)(double const &,double *,unsigned int const &,unsigned int const &)", 0, 0, (void*)0, 0};
20419
20700
  static swig_type_info _swigt__p_self_t = {"_p_self_t", "self_t *", 0, 0, (void*)0, 0};
20420
20701
  static swig_type_info _swigt__p_swig__GC_VALUE = {"_p_swig__GC_VALUE", "swig::GC_VALUE *", 0, 0, (void*)0, 0};
20702
+ static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *", 0, 0, (void*)0, 0};
20421
20703
 
20422
20704
  static swig_type_info *swig_type_initial[] = {
20423
20705
  &_swigt__p_ComplexT_double_t,
@@ -20435,6 +20717,7 @@ static swig_type_info *swig_type_initial[] = {
20435
20717
  &_swigt__p_f_r_q_const__double_p_double_r_q_const__unsigned_int_r_q_const__unsigned_int__void,
20436
20718
  &_swigt__p_self_t,
20437
20719
  &_swigt__p_swig__GC_VALUE,
20720
+ &_swigt__p_unsigned_int,
20438
20721
  };
20439
20722
 
20440
20723
  static swig_cast_info _swigc__p_ComplexT_double_t[] = { {&_swigt__p_ComplexT_double_t, 0, 0, 0},{0, 0, 0, 0}};
@@ -20452,6 +20735,7 @@ static swig_cast_info _swigc__p_f_r_q_const__Complex__double___p_Complex__double
20452
20735
  static swig_cast_info _swigc__p_f_r_q_const__double_p_double_r_q_const__unsigned_int_r_q_const__unsigned_int__void[] = { {&_swigt__p_f_r_q_const__double_p_double_r_q_const__unsigned_int_r_q_const__unsigned_int__void, 0, 0, 0},{0, 0, 0, 0}};
20453
20736
  static swig_cast_info _swigc__p_self_t[] = { {&_swigt__p_self_t, 0, 0, 0},{0, 0, 0, 0}};
20454
20737
  static swig_cast_info _swigc__p_swig__GC_VALUE[] = { {&_swigt__p_swig__GC_VALUE, 0, 0, 0},{0, 0, 0, 0}};
20738
+ static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
20455
20739
 
20456
20740
  static swig_cast_info *swig_cast_initial[] = {
20457
20741
  _swigc__p_ComplexT_double_t,
@@ -20469,6 +20753,7 @@ static swig_cast_info *swig_cast_initial[] = {
20469
20753
  _swigc__p_f_r_q_const__double_p_double_r_q_const__unsigned_int_r_q_const__unsigned_int__void,
20470
20754
  _swigc__p_self_t,
20471
20755
  _swigc__p_swig__GC_VALUE,
20756
+ _swigc__p_unsigned_int,
20472
20757
  };
20473
20758
 
20474
20759
 
@@ -20893,16 +21178,17 @@ SWIGEXPORT void Init_SylphideMath(void) {
20893
21178
  SWIG_TypeClientData(SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, (void *) &SwigClassMatrixD);
20894
21179
  rb_define_alloc_func(SwigClassMatrixD.klass, _wrap_MatrixD_allocate);
20895
21180
  rb_define_method(SwigClassMatrixD.klass, "initialize", VALUEFUNC(_wrap_new_MatrixD), -1);
20896
- rb_define_method(SwigClassMatrixD.klass, "swap_rows!", VALUEFUNC(_wrap_MatrixD_swap_rowsN___), -1);
20897
- rb_define_method(SwigClassMatrixD.klass, "swap_columns!", VALUEFUNC(_wrap_MatrixD_swap_columnsN___), -1);
20898
21181
  rb_define_method(SwigClassMatrixD.klass, "[]=", VALUEFUNC(_wrap_MatrixD___setitem__), -1);
20899
21182
  rb_define_singleton_method(SwigClassMatrixD.klass, "scalar", VALUEFUNC(_wrap_MatrixD_scalar), -1);
20900
21183
  rb_define_singleton_method(SwigClassMatrixD.klass, "I", VALUEFUNC(_wrap_MatrixD_I), -1);
21184
+ rb_define_method(SwigClassMatrixD.klass, "swap_rows!", VALUEFUNC(_wrap_MatrixD_swap_rowsN___), -1);
21185
+ rb_define_method(SwigClassMatrixD.klass, "swap_columns!", VALUEFUNC(_wrap_MatrixD_swap_columnsN___), -1);
20901
21186
  rb_define_method(SwigClassMatrixD.klass, "replace!", VALUEFUNC(_wrap_MatrixD_replaceN___), -1);
20902
21187
  rb_define_method(SwigClassMatrixD.klass, "map!", VALUEFUNC(_wrap_MatrixD_mapN___), -1);
20903
21188
  rb_define_alias(SwigClassMatrixD.klass, "collect!", "map!");
20904
21189
  rb_define_alias(SwigClassMatrixD.klass, "map_with_index!", "map!");
20905
21190
  rb_define_alias(SwigClassMatrixD.klass, "collect_with_index!", "map!");
21191
+ rb_define_method(SwigClassMatrixD.klass, "resize!", VALUEFUNC(_wrap_MatrixD_resizeN___), -1);
20906
21192
  SwigClassMatrixD.mark = 0;
20907
21193
  SwigClassMatrixD.destroy = (void (*)(void *)) free_Matrix_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sg_;
20908
21194
  SwigClassMatrixD.trackObjects = 0;
@@ -21026,16 +21312,17 @@ SWIGEXPORT void Init_SylphideMath(void) {
21026
21312
  SWIG_TypeClientData(SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, (void *) &SwigClassMatrixComplexD);
21027
21313
  rb_define_alloc_func(SwigClassMatrixComplexD.klass, _wrap_MatrixComplexD_allocate);
21028
21314
  rb_define_method(SwigClassMatrixComplexD.klass, "initialize", VALUEFUNC(_wrap_new_MatrixComplexD), -1);
21029
- rb_define_method(SwigClassMatrixComplexD.klass, "swap_rows!", VALUEFUNC(_wrap_MatrixComplexD_swap_rowsN___), -1);
21030
- rb_define_method(SwigClassMatrixComplexD.klass, "swap_columns!", VALUEFUNC(_wrap_MatrixComplexD_swap_columnsN___), -1);
21031
21315
  rb_define_method(SwigClassMatrixComplexD.klass, "[]=", VALUEFUNC(_wrap_MatrixComplexD___setitem__), -1);
21032
21316
  rb_define_singleton_method(SwigClassMatrixComplexD.klass, "scalar", VALUEFUNC(_wrap_MatrixComplexD_scalar), -1);
21033
21317
  rb_define_singleton_method(SwigClassMatrixComplexD.klass, "I", VALUEFUNC(_wrap_MatrixComplexD_I), -1);
21318
+ rb_define_method(SwigClassMatrixComplexD.klass, "swap_rows!", VALUEFUNC(_wrap_MatrixComplexD_swap_rowsN___), -1);
21319
+ rb_define_method(SwigClassMatrixComplexD.klass, "swap_columns!", VALUEFUNC(_wrap_MatrixComplexD_swap_columnsN___), -1);
21034
21320
  rb_define_method(SwigClassMatrixComplexD.klass, "replace!", VALUEFUNC(_wrap_MatrixComplexD_replaceN___), -1);
21035
21321
  rb_define_method(SwigClassMatrixComplexD.klass, "map!", VALUEFUNC(_wrap_MatrixComplexD_mapN___), -1);
21036
21322
  rb_define_alias(SwigClassMatrixComplexD.klass, "collect!", "map!");
21037
21323
  rb_define_alias(SwigClassMatrixComplexD.klass, "map_with_index!", "map!");
21038
21324
  rb_define_alias(SwigClassMatrixComplexD.klass, "collect_with_index!", "map!");
21325
+ rb_define_method(SwigClassMatrixComplexD.klass, "resize!", VALUEFUNC(_wrap_MatrixComplexD_resizeN___), -1);
21039
21326
  SwigClassMatrixComplexD.mark = 0;
21040
21327
  SwigClassMatrixComplexD.destroy = (void (*)(void *)) free_Matrix_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sg_;
21041
21328
  SwigClassMatrixComplexD.trackObjects = 0;