Class: GPS_PVT::SylphideMath::Matrix_FrozenD

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

Overview

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

Instance Method Summary collapse

Instance Method Details

#*(*args, self) ⇒ Object 



7962
7963
7964
7965
7966
7967
7968
7969
7970
7971
7972
7973
7974
7975
7976
7977
7978
7979
7980
7981
7982
7983
7984
7985
7986
7987
7988
7989
7990
7991
7992
7993
7994
7995
7996
7997
7998
7999
8000
8001
8002
8003
8004
8005
8006
8007
8008
8009
8010
8011
8012
8013
8014
8015
8016
8017
8018
8019
8020
8021
8022
8023
8024
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 7962

SWIGINTERN VALUE _wrap_Matrix_FrozenD___mul__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Matrix_FrozenD___mul____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewFilterT_MatrixViewBaseT_t_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Matrix_FrozenD___mul____SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Matrix_FrozenD___mul____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__mul__", 
    "    Matrix< double,Array2D_Dense< double > > __mul__(double const &scalar)\n"
    "    Matrix< double,Array2D_Dense< double > > __mul__(Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const &matrix)\n"
    "    Matrix< double,Array2D_Dense< double > > __mul__(Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const &matrix)\n");
  
  return Qnil;
}

#+(*args, self) ⇒ Object 



7480
7481
7482
7483
7484
7485
7486
7487
7488
7489
7490
7491
7492
7493
7494
7495
7496
7497
7498
7499
7500
7501
7502
7503
7504
7505
7506
7507
7508
7509
7510
7511
7512
7513
7514
7515
7516
7517
7518
7519
7520
7521
7522
7523
7524
7525
7526
7527
7528
7529
7530
7531
7532
7533
7534
7535
7536
7537
7538
7539
7540
7541
7542
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 7480

SWIGINTERN VALUE _wrap_Matrix_FrozenD___add__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Matrix_FrozenD___add____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewFilterT_MatrixViewBaseT_t_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Matrix_FrozenD___add____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Matrix_FrozenD___add____SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__add__", 
    "    Matrix< double,Array2D_Dense< double > > __add__(Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const &matrix)\n"
    "    Matrix< double,Array2D_Dense< double > > __add__(Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const &matrix)\n"
    "    Matrix< double,Array2D_Dense< double > > __add__(double const &scalar)\n");
  
  return Qnil;
}

#-(*args, self) ⇒ Object 



7671
7672
7673
7674
7675
7676
7677
7678
7679
7680
7681
7682
7683
7684
7685
7686
7687
7688
7689
7690
7691
7692
7693
7694
7695
7696
7697
7698
7699
7700
7701
7702
7703
7704
7705
7706
7707
7708
7709
7710
7711
7712
7713
7714
7715
7716
7717
7718
7719
7720
7721
7722
7723
7724
7725
7726
7727
7728
7729
7730
7731
7732
7733
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 7671

SWIGINTERN VALUE _wrap_Matrix_FrozenD___sub__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Matrix_FrozenD___sub____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewFilterT_MatrixViewBaseT_t_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Matrix_FrozenD___sub____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Matrix_FrozenD___sub____SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__sub__", 
    "    Matrix< double,Array2D_Dense< double > > __sub__(Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const &matrix)\n"
    "    Matrix< double,Array2D_Dense< double > > __sub__(Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const &matrix)\n"
    "    Matrix< double,Array2D_Dense< double > > __sub__(double const &scalar)\n");
  
  return Qnil;
}

#-@(*args) ⇒ Object 



7326
7327
7328
7329
7330
7331
7332
7333
7334
7335
7336
7337
7338
7339
7340
7341
7342
7343
7344
7345
7346
7347
7348
7349
7350
7351
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 7326

SWIGINTERN VALUE
_wrap_Matrix_FrozenD___neg__(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Matrix< double,Array2D_Dense< double > > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  try {
    result = Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__operator_Ss_((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1);
  } catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  vresult = SWIG_NewPointerObj((new Matrix< double,Array2D_Dense< double > >(static_cast< const Matrix< double,Array2D_Dense< double > >& >(result))), SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#/(*args, self) ⇒ Object 



8409
8410
8411
8412
8413
8414
8415
8416
8417
8418
8419
8420
8421
8422
8423
8424
8425
8426
8427
8428
8429
8430
8431
8432
8433
8434
8435
8436
8437
8438
8439
8440
8441
8442
8443
8444
8445
8446
8447
8448
8449
8450
8451
8452
8453
8454
8455
8456
8457
8458
8459
8460
8461
8462
8463
8464
8465
8466
8467
8468
8469
8470
8471
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 8409

SWIGINTERN VALUE _wrap_Matrix_FrozenD___div__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Matrix_FrozenD___div____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewFilterT_MatrixViewBaseT_t_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Matrix_FrozenD___div____SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Matrix_FrozenD___div____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__div__", 
    "    Matrix< double,Array2D_Dense< double > > __div__(double const &scalar)\n"
    "    Matrix< double,Array2D_Dense< double > > __div__(Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const &matrix)\n"
    "    Matrix< double,Array2D_Dense< double > > __div__(Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const &matrix)\n");
  
  return Qnil;
}

#==(*args, self) ⇒ Object 



7050
7051
7052
7053
7054
7055
7056
7057
7058
7059
7060
7061
7062
7063
7064
7065
7066
7067
7068
7069
7070
7071
7072
7073
7074
7075
7076
7077
7078
7079
7080
7081
7082
7083
7084
7085
7086
7087
7088
7089
7090
7091
7092
7093
7094
7095
7096
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 7050

SWIGINTERN VALUE _wrap_Matrix_FrozenD___eq__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Matrix_FrozenD___eq____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewFilterT_MatrixViewBaseT_t_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Matrix_FrozenD___eq____SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__eq__", 
    "    bool __eq__(Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const &matrix)\n"
    "    bool __eq__(Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const &matrix)\n");
  
  return Qnil;
}

#[](*args) ⇒ Object Also known as: element, component 



6692
6693
6694
6695
6696
6697
6698
6699
6700
6701
6702
6703
6704
6705
6706
6707
6708
6709
6710
6711
6712
6713
6714
6715
6716
6717
6718
6719
6720
6721
6722
6723
6724
6725
6726
6727
6728
6729
6730
6731
6732
6733
6734
6735
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 6692

SWIGINTERN VALUE
_wrap_Matrix_FrozenD___getitem__(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  unsigned int *arg2 = 0 ;
  unsigned int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int temp2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int temp3 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","__getitem__", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","__getitem__", 2, argv[0] ));
  } 
  temp2 = static_cast< unsigned int >(val2);
  arg2 = &temp2;
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","__getitem__", 3, argv[1] ));
  } 
  temp3 = static_cast< unsigned int >(val3);
  arg3 = &temp3;
  raise_if_lt_zero_after_asval(*arg2);
  raise_if_lt_zero_after_asval(*arg3);
  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);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#adjoint(*args) ⇒ Object 



9137
9138
9139
9140
9141
9142
9143
9144
9145
9146
9147
9148
9149
9150
9151
9152
9153
9154
9155
9156
9157
9158
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 9137

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_adjoint(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","adjoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__adjoint((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1);
  vresult = SWIG_NewPointerObj((new Matrix_Frozen< double,Array2D_Dense< double >,MatView_f >(static_cast< const Matrix_Frozen< double,Array2D_Dense< double >,MatView_f >& >(result))), SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewFilterT_MatrixViewBaseT_t_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#adjugate(*args) ⇒ Object 



8091
8092
8093
8094
8095
8096
8097
8098
8099
8100
8101
8102
8103
8104
8105
8106
8107
8108
8109
8110
8111
8112
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 8091

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_adjugate(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Matrix< double,Array2D_Dense< double > > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","adjugate", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__adjugate((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1);
  vresult = SWIG_NewPointerObj((new Matrix< double,Array2D_Dense< double > >(static_cast< const Matrix< double,Array2D_Dense< double > >& >(result))), SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#circular(*args, self) ⇒ Object 



6896
6897
6898
6899
6900
6901
6902
6903
6904
6905
6906
6907
6908
6909
6910
6911
6912
6913
6914
6915
6916
6917
6918
6919
6920
6921
6922
6923
6924
6925
6926
6927
6928
6929
6930
6931
6932
6933
6934
6935
6936
6937
6938
6939
6940
6941
6942
6943
6944
6945
6946
6947
6948
6949
6950
6951
6952
6953
6954
6955
6956
6957
6958
6959
6960
6961
6962
6963
6964
6965
6966
6967
6968
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 6896

SWIGINTERN VALUE _wrap_Matrix_FrozenD_circular(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[6];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 6) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Matrix_FrozenD_circular__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Matrix_FrozenD_circular__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "circular", 
    "    Matrix< double,Array2D_Dense< double > > circular(unsigned int const &row_offset, unsigned int const &column_offset, unsigned int const &new_rows, unsigned int const &new_columns)\n"
    "    Matrix< double,Array2D_Dense< double > > circular(unsigned int const &row_offset, unsigned int const &column_offset)\n");
  
  return Qnil;
}

#cofactor(*args) ⇒ Object 



6632
6633
6634
6635
6636
6637
6638
6639
6640
6641
6642
6643
6644
6645
6646
6647
6648
6649
6650
6651
6652
6653
6654
6655
6656
6657
6658
6659
6660
6661
6662
6663
6664
6665
6666
6667
6668
6669
6670
6671
6672
6673
6674
6675
6676
6677
6678
6679
6680
6681
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 6632

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_cofactor(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  unsigned int *arg2 = 0 ;
  unsigned int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int temp2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int temp3 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","cofactor", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","cofactor", 2, argv[0] ));
  } 
  temp2 = static_cast< unsigned int >(val2);
  arg2 = &temp2;
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","cofactor", 3, argv[1] ));
  } 
  temp3 = static_cast< unsigned int >(val3);
  arg3 = &temp3;
  raise_if_lt_zero_after_asval(*arg2);
  raise_if_lt_zero_after_asval(*arg3);
  try {
    result = (double)((Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *)arg1)->cofactor((unsigned int const &)*arg2,(unsigned int const &)*arg3);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  } catch(std::runtime_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#column_vector(*args) ⇒ Object 



9455
9456
9457
9458
9459
9460
9461
9462
9463
9464
9465
9466
9467
9468
9469
9470
9471
9472
9473
9474
9475
9476
9477
9478
9479
9480
9481
9482
9483
9484
9485
9486
9487
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 9455

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_column_vector(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  unsigned int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int temp2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","column_vector", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","column_vector", 2, argv[0] ));
  } 
  temp2 = static_cast< unsigned int >(val2);
  arg2 = &temp2;
  raise_if_lt_zero_after_asval(*arg2);
  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);
  vresult = SWIG_NewPointerObj((new Matrix_Frozen< double,Array2D_Dense< double >,MatView_f >(static_cast< const Matrix_Frozen< double,Array2D_Dense< double >,MatView_f >& >(result))), SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewFilterT_MatrixViewBaseT_t_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#columns(*args) ⇒ Object Also known as: column_size, column_count 



6123
6124
6125
6126
6127
6128
6129
6130
6131
6132
6133
6134
6135
6136
6137
6138
6139
6140
6141
6142
6143
6144
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 6123

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_columns(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *","columns", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = (unsigned int)(arg1)->columns();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

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



9104
9105
9106
9107
9108
9109
9110
9111
9112
9113
9114
9115
9116
9117
9118
9119
9120
9121
9122
9123
9124
9125
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 9104

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_conjugate(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","conjugate", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__conjugate((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1);
  vresult = SWIG_NewPointerObj((new Matrix_Frozen< double,Array2D_Dense< double >,MatView_f >(static_cast< const Matrix_Frozen< double,Array2D_Dense< double >,MatView_f >& >(result))), SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewFilterT_MatrixViewBaseT_t_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#copy(*args) ⇒ Object 



6747
6748
6749
6750
6751
6752
6753
6754
6755
6756
6757
6758
6759
6760
6761
6762
6763
6764
6765
6766
6767
6768
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 6747

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_copy(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Matrix< double,Array2D_Dense< double > > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","copy", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__copy((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1);
  vresult = SWIG_NewPointerObj((new Matrix< double,Array2D_Dense< double > >(static_cast< const Matrix< double,Array2D_Dense< double > >& >(result))), SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#debug(*args) ⇒ Object 



8483
8484
8485
8486
8487
8488
8489
8490
8491
8492
8493
8494
8495
8496
8497
8498
8499
8500
8501
8502
8503
8504
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 8483

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_debug(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","debug", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__debug((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}

#determinant(*args) ⇒ Object Also known as: det 



6556
6557
6558
6559
6560
6561
6562
6563
6564
6565
6566
6567
6568
6569
6570
6571
6572
6573
6574
6575
6576
6577
6578
6579
6580
6581
6582
6583
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 6556

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_determinant(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","determinant", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  try {
    result = (double)((Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *)arg1)->determinant();
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  } catch(std::runtime_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#diagonal?(*args) ⇒ Object 



6189
6190
6191
6192
6193
6194
6195
6196
6197
6198
6199
6200
6201
6202
6203
6204
6205
6206
6207
6208
6209
6210
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 6189

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_diagonalq___(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","isDiagonal", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = (bool)((Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *)arg1)->isDiagonal();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#different_size?(*args, self) ⇒ Object 



7179
7180
7181
7182
7183
7184
7185
7186
7187
7188
7189
7190
7191
7192
7193
7194
7195
7196
7197
7198
7199
7200
7201
7202
7203
7204
7205
7206
7207
7208
7209
7210
7211
7212
7213
7214
7215
7216
7217
7218
7219
7220
7221
7222
7223
7224
7225
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 7179

SWIGINTERN VALUE _wrap_Matrix_FrozenD_different_sizeq___(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Matrix_FrozenD_different_sizeq_____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewFilterT_MatrixViewBaseT_t_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Matrix_FrozenD_different_sizeq_____SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "different_size?", 
    "    bool different_size?(Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const &matrix)\n"
    "    bool different_size?(Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const &matrix)\n");
  
  return Qnil;
}

#each(*args, self) ⇒ Object Also known as: each_with_index 



8596
8597
8598
8599
8600
8601
8602
8603
8604
8605
8606
8607
8608
8609
8610
8611
8612
8613
8614
8615
8616
8617
8618
8619
8620
8621
8622
8623
8624
8625
8626
8627
8628
8629
8630
8631
8632
8633
8634
8635
8636
8637
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 8596

SWIGINTERN VALUE _wrap_Matrix_FrozenD_each(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Matrix_FrozenD_each__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = (MatrixUtil::sym2each_which(argv[1]) != MatrixUtil::EACH_UNKNOWN);
      }
      if (_v) {
        return _wrap_Matrix_FrozenD_each__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "each", 
    "    Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const each(void (*each_func)(double const &,double *,unsigned int const &,unsigned int const &), MatrixUtil::each_which_t const each_which)\n"
    "    Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const & each(void (*each_func)(double const &,double *,unsigned int const &,unsigned int const &))\n");
  
  return Qnil;
}

#eigen(*args) ⇒ Object 



9499
9500
9501
9502
9503
9504
9505
9506
9507
9508
9509
9510
9511
9512
9513
9514
9515
9516
9517
9518
9519
9520
9521
9522
9523
9524
9525
9526
9527
9528
9529
9530
9531
9532
9533
9534
9535
9536
9537
9538
9539
9540
9541
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 9499

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_eigen(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *arg2 = 0 ;
  Matrix< Complex< double >,Array2D_Dense< Complex< double > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Matrix< Complex< double >,Array2D_Dense< Complex< double > > > temp2 ;
  Matrix< Complex< double >,Array2D_Dense< Complex< double > > > temp3 ;
  VALUE vresult = Qnil;
  
  
  arg2 = &temp2;
  
  
  arg3 = &temp3;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","eigen", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  try {
    Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__eigen((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1,*arg2,*arg3);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  } catch(std::runtime_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = rb_ary_new();
  {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new Matrix< Complex< double >,Array2D_Dense< Complex< double > > >(*arg2)), SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, SWIG_POINTER_OWN));
  }
  {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new Matrix< Complex< double >,Array2D_Dense< Complex< double > > >(*arg3)), SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, SWIG_POINTER_OWN));
  }
  return vresult;
fail:
  return Qnil;
}

#entrywise_product(*args, self) ⇒ Object Also known as: hadamard_product 



7824
7825
7826
7827
7828
7829
7830
7831
7832
7833
7834
7835
7836
7837
7838
7839
7840
7841
7842
7843
7844
7845
7846
7847
7848
7849
7850
7851
7852
7853
7854
7855
7856
7857
7858
7859
7860
7861
7862
7863
7864
7865
7866
7867
7868
7869
7870
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 7824

SWIGINTERN VALUE _wrap_Matrix_FrozenD_entrywise_product(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Matrix_FrozenD_entrywise_product__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewFilterT_MatrixViewBaseT_t_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Matrix_FrozenD_entrywise_product__SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "entrywise_product", 
    "    Matrix< double,Array2D_Dense< double > > entrywise_product(Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const &matrix)\n"
    "    Matrix< double,Array2D_Dense< double > > entrywise_product(Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const &matrix)\n");
  
  return Qnil;
}

#first_minor(*args) ⇒ Object 



8036
8037
8038
8039
8040
8041
8042
8043
8044
8045
8046
8047
8048
8049
8050
8051
8052
8053
8054
8055
8056
8057
8058
8059
8060
8061
8062
8063
8064
8065
8066
8067
8068
8069
8070
8071
8072
8073
8074
8075
8076
8077
8078
8079
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 8036

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_first_minor(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  unsigned int *arg2 = 0 ;
  unsigned int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int temp2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int temp3 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Matrix< double,Array2D_Dense< double > > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","first_minor", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","first_minor", 2, argv[0] ));
  } 
  temp2 = static_cast< unsigned int >(val2);
  arg2 = &temp2;
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","first_minor", 3, argv[1] ));
  } 
  temp3 = static_cast< unsigned int >(val3);
  arg3 = &temp3;
  raise_if_lt_zero_after_asval(*arg2);
  raise_if_lt_zero_after_asval(*arg3);
  result = Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__first_minor((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1,(unsigned int const &)*arg2,(unsigned int const &)*arg3);
  vresult = SWIG_NewPointerObj((new Matrix< double,Array2D_Dense< double > >(static_cast< const Matrix< double,Array2D_Dense< double > >& >(result))), SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#hermitian?(*args) ⇒ Object 



6321
6322
6323
6324
6325
6326
6327
6328
6329
6330
6331
6332
6333
6334
6335
6336
6337
6338
6339
6340
6341
6342
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 6321

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_hermitianq___(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","isHermitian", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = (bool)((Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *)arg1)->isHermitian();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#index(*args, self) ⇒ Object Also known as: find_index 



8924
8925
8926
8927
8928
8929
8930
8931
8932
8933
8934
8935
8936
8937
8938
8939
8940
8941
8942
8943
8944
8945
8946
8947
8948
8949
8950
8951
8952
8953
8954
8955
8956
8957
8958
8959
8960
8961
8962
8963
8964
8965
8966
8967
8968
8969
8970
8971
8972
8973
8974
8975
8976
8977
8978
8979
8980
8981
8982
8983
8984
8985
8986
8987
8988
8989
8990
8991
8992
8993
8994
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 8924

SWIGINTERN VALUE _wrap_Matrix_FrozenD_index(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Matrix_FrozenD_index__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = (MatrixUtil::sym2each_which(argv[1]) != MatrixUtil::EACH_UNKNOWN);
      }
      if (_v) {
        return _wrap_Matrix_FrozenD_index__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        return _wrap_Matrix_FrozenD_index__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_Matrix_FrozenD_index__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "index", 
    "    VALUE index(MatrixUtil::each_which_t const each_which)\n"
    "    VALUE index()\n"
    "    VALUE index(VALUE value, VALUE idx_selector)\n"
    "    VALUE index(VALUE value)\n");
  
  return Qnil;
}

#inverse(*args) ⇒ Object Also known as: inv 



8286
8287
8288
8289
8290
8291
8292
8293
8294
8295
8296
8297
8298
8299
8300
8301
8302
8303
8304
8305
8306
8307
8308
8309
8310
8311
8312
8313
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 8286

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_inverse(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Matrix< double,Array2D_Dense< double > > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","inverse", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  try {
    result = Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__inverse((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  } catch(std::runtime_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = SWIG_NewPointerObj((new Matrix< double,Array2D_Dense< double > >(static_cast< const Matrix< double,Array2D_Dense< double > >& >(result))), SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#lower_triangular?(*args) ⇒ Object 



6222
6223
6224
6225
6226
6227
6228
6229
6230
6231
6232
6233
6234
6235
6236
6237
6238
6239
6240
6241
6242
6243
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 6222

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_lower_triangularq___(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","isLowerTriangular", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = (bool)((Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *)arg1)->isLowerTriangular();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#lup(*args) ⇒ Object Also known as: lup_decomposition 



8124
8125
8126
8127
8128
8129
8130
8131
8132
8133
8134
8135
8136
8137
8138
8139
8140
8141
8142
8143
8144
8145
8146
8147
8148
8149
8150
8151
8152
8153
8154
8155
8156
8157
8158
8159
8160
8161
8162
8163
8164
8165
8166
8167
8168
8169
8170
8171
8172
8173
8174
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 8124

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_lup(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  Matrix< double,Array2D_Dense< double > > *arg2 = 0 ;
  Matrix< double,Array2D_Dense< double > > *arg3 = 0 ;
  Matrix< double,Array2D_Dense< double > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Matrix< double,Array2D_Dense< double > > temp2 ;
  Matrix< double,Array2D_Dense< double > > temp3 ;
  Matrix< double,Array2D_Dense< double > > temp4 ;
  VALUE vresult = Qnil;
  
  
  arg2 = &temp2;
  
  
  arg3 = &temp3;
  
  
  arg4 = &temp4;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","lup", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  try {
    Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__lup((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1,*arg2,*arg3,*arg4);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  } catch(std::runtime_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = rb_ary_new();
  {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new Matrix< double,Array2D_Dense< double > >(*arg2)), SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_OWN));
  }
  {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new Matrix< double,Array2D_Dense< double > >(*arg3)), SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_OWN));
  }
  {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new Matrix< double,Array2D_Dense< double > >(*arg4)), SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_OWN));
  }
  return vresult;
fail:
  return Qnil;
}

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



8734
8735
8736
8737
8738
8739
8740
8741
8742
8743
8744
8745
8746
8747
8748
8749
8750
8751
8752
8753
8754
8755
8756
8757
8758
8759
8760
8761
8762
8763
8764
8765
8766
8767
8768
8769
8770
8771
8772
8773
8774
8775
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 8734

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

#normal?(*args) ⇒ Object 



6387
6388
6389
6390
6391
6392
6393
6394
6395
6396
6397
6398
6399
6400
6401
6402
6403
6404
6405
6406
6407
6408
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 6387

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_normalq___(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","isNormal", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = (bool)((Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *)arg1)->isNormal();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#orthogonal?(*args) ⇒ Object 



6420
6421
6422
6423
6424
6425
6426
6427
6428
6429
6430
6431
6432
6433
6434
6435
6436
6437
6438
6439
6440
6441
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 6420

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_orthogonalq___(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","isOrthogonal", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = (bool)((Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *)arg1)->isOrthogonal();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#partial(*args, self) ⇒ Object 



9327
9328
9329
9330
9331
9332
9333
9334
9335
9336
9337
9338
9339
9340
9341
9342
9343
9344
9345
9346
9347
9348
9349
9350
9351
9352
9353
9354
9355
9356
9357
9358
9359
9360
9361
9362
9363
9364
9365
9366
9367
9368
9369
9370
9371
9372
9373
9374
9375
9376
9377
9378
9379
9380
9381
9382
9383
9384
9385
9386
9387
9388
9389
9390
9391
9392
9393
9394
9395
9396
9397
9398
9399
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 9327

SWIGINTERN VALUE _wrap_Matrix_FrozenD_partial(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[6];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 6) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Matrix_FrozenD_partial__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Matrix_FrozenD_partial__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "partial", 
    "    Matrix_Frozen< double,Array2D_Dense< double >,MatView_f > partial(unsigned int const &new_rows, unsigned int const &new_columns, unsigned int const &row_offset, unsigned int const &column_offset)\n"
    "    Matrix_Frozen< double,Array2D_Dense< double >,MatView_f > partial(unsigned int const &new_rows, unsigned int const &new_columns)\n");
  
  return Qnil;
}

#qr(*args) ⇒ Object Also known as: qr_decomposition 



8238
8239
8240
8241
8242
8243
8244
8245
8246
8247
8248
8249
8250
8251
8252
8253
8254
8255
8256
8257
8258
8259
8260
8261
8262
8263
8264
8265
8266
8267
8268
8269
8270
8271
8272
8273
8274
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 8238

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_qr(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  Matrix< double,Array2D_Dense< double > > *arg2 = 0 ;
  Matrix< double,Array2D_Dense< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Matrix< double,Array2D_Dense< double > > temp2 ;
  Matrix< double,Array2D_Dense< double > > temp3 ;
  VALUE vresult = Qnil;
  
  
  arg2 = &temp2;
  
  
  arg3 = &temp3;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","qr", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__qr((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1,*arg2,*arg3);
  vresult = rb_ary_new();
  {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new Matrix< double,Array2D_Dense< double > >(*arg2)), SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_OWN));
  }
  {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new Matrix< double,Array2D_Dense< double > >(*arg3)), SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_OWN));
  }
  return vresult;
fail:
  return Qnil;
}

#rank(*args) ⇒ Object 



6595
6596
6597
6598
6599
6600
6601
6602
6603
6604
6605
6606
6607
6608
6609
6610
6611
6612
6613
6614
6615
6616
6617
6618
6619
6620
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 6595

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_rank(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","rank", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  try {
    result = (unsigned int)((Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *)arg1)->rank();
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

#row_vector(*args) ⇒ Object 



9411
9412
9413
9414
9415
9416
9417
9418
9419
9420
9421
9422
9423
9424
9425
9426
9427
9428
9429
9430
9431
9432
9433
9434
9435
9436
9437
9438
9439
9440
9441
9442
9443
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 9411

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_row_vector(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  unsigned int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int temp2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","row_vector", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","row_vector", 2, argv[0] ));
  } 
  temp2 = static_cast< unsigned int >(val2);
  arg2 = &temp2;
  raise_if_lt_zero_after_asval(*arg2);
  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);
  vresult = SWIG_NewPointerObj((new Matrix_Frozen< double,Array2D_Dense< double >,MatView_f >(static_cast< const Matrix_Frozen< double,Array2D_Dense< double >,MatView_f >& >(result))), SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewFilterT_MatrixViewBaseT_t_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#rows(*args) ⇒ Object Also known as: row_size, row_count 



6090
6091
6092
6093
6094
6095
6096
6097
6098
6099
6100
6101
6102
6103
6104
6105
6106
6107
6108
6109
6110
6111
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 6090

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_rows(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *","rows", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = (unsigned int)(arg1)->rows();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

#skew_symmetric?(*args) ⇒ Object Also known as: antisymmetric? 



6354
6355
6356
6357
6358
6359
6360
6361
6362
6363
6364
6365
6366
6367
6368
6369
6370
6371
6372
6373
6374
6375
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 6354

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_skew_symmetricq___(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","isSkewSymmetric", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = (bool)((Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *)arg1)->isSkewSymmetric();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#square?(*args) ⇒ Object 



6156
6157
6158
6159
6160
6161
6162
6163
6164
6165
6166
6167
6168
6169
6170
6171
6172
6173
6174
6175
6176
6177
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 6156

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_squareq___(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","isSquare", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = (bool)((Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *)arg1)->isSquare();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#sum(*args) ⇒ Object 



6523
6524
6525
6526
6527
6528
6529
6530
6531
6532
6533
6534
6535
6536
6537
6538
6539
6540
6541
6542
6543
6544
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 6523

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_sum(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","sum", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = (double)((Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *)arg1)->sum();
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#symmetric?(*args) ⇒ Object 



6288
6289
6290
6291
6292
6293
6294
6295
6296
6297
6298
6299
6300
6301
6302
6303
6304
6305
6306
6307
6308
6309
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 6288

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_symmetricq___(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","isSymmetric", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = (bool)((Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *)arg1)->isSymmetric();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#to_a(*args) ⇒ Object 



9005
9006
9007
9008
9009
9010
9011
9012
9013
9014
9015
9016
9017
9018
9019
9020
9021
9022
9023
9024
9025
9026
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 9005

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_to_a(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","to_a", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = (VALUE)Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__to_a((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#to_s(*args) ⇒ Object 



9071
9072
9073
9074
9075
9076
9077
9078
9079
9080
9081
9082
9083
9084
9085
9086
9087
9088
9089
9090
9091
9092
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 9071

SWIGINTERN VALUE
_wrap_Matrix_FrozenD___str__(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","__str__", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg____str__((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}

#to_shareable(*args) ⇒ Object 



9038
9039
9040
9041
9042
9043
9044
9045
9046
9047
9048
9049
9050
9051
9052
9053
9054
9055
9056
9057
9058
9059
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 9038

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_to_shareable(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","to_shareable", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = (VALUE)Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__to_shareable((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#trace(*args) ⇒ Object Also known as: tr 



6486
6487
6488
6489
6490
6491
6492
6493
6494
6495
6496
6497
6498
6499
6500
6501
6502
6503
6504
6505
6506
6507
6508
6509
6510
6511
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 6486

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_trace(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","trace", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  try {
    result = (double)((Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *)arg1)->trace();
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#transpose(*args) ⇒ Object Also known as: t 



9170
9171
9172
9173
9174
9175
9176
9177
9178
9179
9180
9181
9182
9183
9184
9185
9186
9187
9188
9189
9190
9191
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 9170

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_transpose(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","transpose", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__transpose((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1);
  vresult = SWIG_NewPointerObj((new Matrix_Frozen< double,Array2D_Dense< double >,MatView_f >(static_cast< const Matrix_Frozen< double,Array2D_Dense< double >,MatView_f >& >(result))), SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewFilterT_MatrixViewBaseT_t_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#ud(*args) ⇒ Object Also known as: ud_decomposition 



8186
8187
8188
8189
8190
8191
8192
8193
8194
8195
8196
8197
8198
8199
8200
8201
8202
8203
8204
8205
8206
8207
8208
8209
8210
8211
8212
8213
8214
8215
8216
8217
8218
8219
8220
8221
8222
8223
8224
8225
8226
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 8186

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_ud(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  Matrix< double,Array2D_Dense< double > > *arg2 = 0 ;
  Matrix< double,Array2D_Dense< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Matrix< double,Array2D_Dense< double > > temp2 ;
  Matrix< double,Array2D_Dense< double > > temp3 ;
  VALUE vresult = Qnil;
  
  
  arg2 = &temp2;
  
  
  arg3 = &temp3;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","ud", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  try {
    Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__ud((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1,*arg2,*arg3);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = rb_ary_new();
  {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new Matrix< double,Array2D_Dense< double > >(*arg2)), SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_OWN));
  }
  {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((new Matrix< double,Array2D_Dense< double > >(*arg3)), SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, SWIG_POINTER_OWN));
  }
  return vresult;
fail:
  return Qnil;
}

#unitary?(*args) ⇒ Object 



6453
6454
6455
6456
6457
6458
6459
6460
6461
6462
6463
6464
6465
6466
6467
6468
6469
6470
6471
6472
6473
6474
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 6453

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_unitaryq___(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","isUnitary", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = (bool)((Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *)arg1)->isUnitary();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#upper_triangular?(*args) ⇒ Object 



6255
6256
6257
6258
6259
6260
6261
6262
6263
6264
6265
6266
6267
6268
6269
6270
6271
6272
6273
6274
6275
6276
 
# File 'ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx', line 6255

SWIGINTERN VALUE
_wrap_Matrix_FrozenD_upper_triangularq___(int argc, VALUE *argv, VALUE self) {
  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","isUpperTriangular", 1, self )); 
  }
  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
  result = (bool)((Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *)arg1)->isUpperTriangular();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}